/*
 *   Copyright (c) 2008-2019 SLIBIO <https://github.com/SLIBIO>
 *
 *   Permission is hereby granted, free of charge, to any person obtaining a copy
 *   of this software and associated documentation files (the "Software"), to deal
 *   in the Software without restriction, including without limitation the rights
 *   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 *   copies of the Software, and to permit persons to whom the Software is
 *   furnished to do so, subject to the following conditions:
 *
 *   The above copyright notice and this permission notice shall be included in
 *   all copies or substantial portions of the Software.
 *
 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 *   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 *   THE SOFTWARE.
 */

namespace slib
{
	
	class EllipticCurve_secp256k1 : public EllipticCurve
	{
	public:
		EllipticCurve_secp256k1()
		{
			static const sl_uint8 _p[] = {
				0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
				0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
				0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
				0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFC, 0x2F
			};
			p = BigInt::fromBytesBE(_p, sizeof(_p));
			a = BigInt::null();
			b = BigInt::fromUint32(7);
			static const sl_uint8 _gx[] = {
				0x79, 0xBE, 0x66, 0x7E, 0xF9, 0xDC, 0xBB, 0xAC,
				0x55, 0xA0, 0x62, 0x95, 0xCE, 0x87, 0x0B, 0x07,
				0x02, 0x9B, 0xFC, 0xDB, 0x2D, 0xCE, 0x28, 0xD9,
				0x59, 0xF2, 0x81, 0x5B, 0x16, 0xF8, 0x17, 0x98
			};
			G.x = BigInt::fromBytesBE(_gx, sizeof(_gx));
			static const sl_uint8 _gy[] = {
				0x48, 0x3a, 0xda, 0x77, 0x26, 0xa3, 0xc4, 0x65,
				0x5d, 0xa4, 0xfb, 0xfc, 0x0e, 0x11, 0x08, 0xa8,
				0xfd, 0x17, 0xb4, 0x48, 0xa6, 0x85, 0x54, 0x19,
				0x9c, 0x47, 0xd0, 0x8f, 0xfb, 0x10, 0xd4, 0xb8
			};
			G.y = BigInt::fromBytesBE(_gy, sizeof(_gy));
			static const sl_uint8 _n[] = {
				0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
				0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
				0xBA, 0xAE, 0xDC, 0xE6, 0xAF, 0x48, 0xA0, 0x3B,
				0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41, 0x41
			};
			n = BigInt::fromBytesBE(_n, sizeof(_n));
			/*
			ECPoint pt;
			// (2^1)*G
			{
				const static sl_uint8 _x[] = {0xC6,0x04,0x7F,0x94,0x41,0xED,0x7D,0x6D,0x30,0x45,0x40,0x6E,0x95,0xC0,0x7C,0xD8,0x5C,0x77,0x8E,0x4B,0x8C,0xEF,0x3C,0xA7,0xAB,0xAC,0x09,0xB9,0x5C,0x70,0x9E,0xE5};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x1A,0xE1,0x68,0xFE,0xA6,0x3D,0xC3,0x39,0xA3,0xC5,0x84,0x19,0x46,0x6C,0xEA,0xEE,0xF7,0xF6,0x32,0x65,0x32,0x66,0xD0,0xE1,0x23,0x64,0x31,0xA9,0x50,0xCF,0xE5,0x2A};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^2)*G
			{
				const static sl_uint8 _x[] = {0xE4,0x93,0xDB,0xF1,0xC1,0x0D,0x80,0xF3,0x58,0x1E,0x49,0x04,0x93,0x0B,0x14,0x04,0xCC,0x6C,0x13,0x90,0x0E,0xE0,0x75,0x84,0x74,0xFA,0x94,0xAB,0xE8,0xC4,0xCD,0x13};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x51,0xED,0x99,0x3E,0xA0,0xD4,0x55,0xB7,0x56,0x42,0xE2,0x09,0x8E,0xA5,0x14,0x48,0xD9,0x67,0xAE,0x33,0xBF,0xBD,0xFE,0x40,0xCF,0xE9,0x7B,0xDC,0x47,0x73,0x99,0x22};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^3)*G
			{
				const static sl_uint8 _x[] = {0x2F,0x01,0xE5,0xE1,0x5C,0xCA,0x35,0x1D,0xAF,0xF3,0x84,0x3F,0xB7,0x0F,0x3C,0x2F,0x0A,0x1B,0xDD,0x05,0xE5,0xAF,0x88,0x8A,0x67,0x78,0x4E,0xF3,0xE1,0x0A,0x2A,0x01};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x5C,0x4D,0xA8,0xA7,0x41,0x53,0x99,0x49,0x29,0x3D,0x08,0x2A,0x13,0x2D,0x13,0xB4,0xC2,0xE2,0x13,0xD6,0xBA,0x5B,0x76,0x17,0xB5,0xDA,0x2C,0xB7,0x6C,0xBD,0xE9,0x04};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^4)*G
			{
				const static sl_uint8 _x[] = {0xE6,0x0F,0xCE,0x93,0xB5,0x9E,0x9E,0xC5,0x30,0x11,0xAA,0xBC,0x21,0xC2,0x3E,0x97,0xB2,0xA3,0x13,0x69,0xB8,0x7A,0x5A,0xE9,0xC4,0x4E,0xE8,0x9E,0x2A,0x6D,0xEC,0x0A};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xF7,0xE3,0x50,0x73,0x99,0xE5,0x95,0x92,0x9D,0xB9,0x9F,0x34,0xF5,0x79,0x37,0x10,0x12,0x96,0x89,0x1E,0x44,0xD2,0x3F,0x0B,0xE1,0xF3,0x2C,0xCE,0x69,0x61,0x68,0x21};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^5)*G
			{
				const static sl_uint8 _x[] = {0xD3,0x01,0x99,0xD7,0x4F,0xB5,0xA2,0x2D,0x47,0xB6,0xE0,0x54,0xE2,0xF3,0x78,0xCE,0xDA,0xCF,0xFC,0xB8,0x99,0x04,0xA6,0x1D,0x75,0xD0,0xDB,0xD4,0x07,0x14,0x3E,0x65};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x95,0x03,0x8D,0x9D,0x0A,0xE3,0xD5,0xC3,0xB3,0xD6,0xDE,0xC9,0xE9,0x83,0x80,0x65,0x1F,0x76,0x0C,0xC3,0x64,0xED,0x81,0x96,0x05,0xB3,0xFF,0x1F,0x24,0x10,0x6A,0xB9};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^6)*G
			{
				const static sl_uint8 _x[] = {0xBF,0x23,0xC1,0x54,0x2D,0x16,0xEA,0xB7,0x0B,0x10,0x51,0xEA,0xF8,0x32,0x82,0x3C,0xFC,0x4C,0x6F,0x1D,0xCD,0xBA,0xFD,0x81,0xE3,0x79,0x18,0xE6,0xF8,0x74,0xEF,0x8B};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x5C,0xB3,0x86,0x6F,0xC3,0x30,0x03,0x73,0x7A,0xD9,0x28,0xA0,0xBA,0x53,0x92,0xE4,0xC5,0x22,0xFC,0x54,0x81,0x1E,0x2F,0x78,0x4D,0xC3,0x7E,0xFE,0x66,0x83,0x1D,0x9F};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^7)*G
			{
				const static sl_uint8 _x[] = {0x34,0xFF,0x3B,0xE4,0x03,0x3F,0x7A,0x06,0x69,0x6C,0x3D,0x09,0xF7,0xD1,0x67,0x1C,0xBC,0xF5,0x5C,0xD7,0x00,0x53,0x56,0x55,0x64,0x70,0x77,0x45,0x67,0x69,0xA2,0x4E};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x5D,0x9D,0x11,0x62,0x3A,0x23,0x6C,0x55,0x3F,0x66,0x19,0xD8,0x98,0x32,0x09,0x8C,0x55,0xDF,0x16,0xC3,0xE8,0xF8,0xB6,0x81,0x84,0x91,0x06,0x7A,0x73,0xCC,0x2F,0x1A};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^8)*G
			{
				const static sl_uint8 _x[] = {0x82,0x82,0x26,0x32,0x12,0xC6,0x09,0xD9,0xEA,0x2A,0x6E,0x3E,0x17,0x2D,0xE2,0x38,0xD8,0xC3,0x9C,0xAB,0xD5,0xAC,0x1C,0xA1,0x06,0x46,0xE2,0x3F,0xD5,0xF5,0x15,0x08};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x11,0xF8,0xA8,0x09,0x85,0x57,0xDF,0xE4,0x5E,0x82,0x56,0xE8,0x30,0xB6,0x0A,0xCE,0x62,0xD6,0x13,0xAC,0x2F,0x7B,0x17,0xBE,0xD3,0x1B,0x6E,0xAF,0xF6,0xE2,0x6C,0xAF};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^9)*G
			{
				const static sl_uint8 _x[] = {0x46,0x53,0x70,0xB2,0x87,0xA7,0x9F,0xF3,0x90,0x5A,0x85,0x7A,0x9C,0xF9,0x18,0xD5,0x0A,0xDB,0xC9,0x68,0xD9,0xE1,0x59,0xD0,0x92,0x6E,0x2C,0x00,0xEF,0x34,0xA2,0x4D};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x35,0xE5,0x31,0xB3,0x83,0x68,0xC0,0x82,0xA4,0xAF,0x8B,0xDA,0xFD,0xEE,0xC2,0xC1,0x58,0x8E,0x09,0xB2,0x15,0xD3,0x7A,0x10,0xA2,0xF8,0xFB,0x20,0xB3,0x38,0x87,0xF4};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^10)*G
			{
				const static sl_uint8 _x[] = {0x24,0x1F,0xEB,0xB8,0xE2,0x3C,0xBD,0x77,0xD6,0x64,0xA1,0x8F,0x66,0xAD,0x62,0x40,0xAA,0xEC,0x6E,0xCD,0xC8,0x13,0xB0,0x88,0xD5,0xB9,0x01,0xB2,0xE2,0x85,0x13,0x1F};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x51,0x33,0x78,0xD9,0xFF,0x94,0xF8,0xD3,0xD6,0xC4,0x20,0xBD,0x13,0x98,0x1D,0xF8,0xCD,0x50,0xFD,0x0F,0xBD,0x0C,0xB5,0xAF,0xAB,0xB3,0xE6,0x6F,0x27,0x50,0x02,0x6D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^11)*G
			{
				const static sl_uint8 _x[] = {0x5D,0x1B,0xDB,0x4E,0xA1,0x72,0xFA,0x79,0xFC,0xE4,0xCC,0x29,0x83,0xD8,0xF8,0xD9,0xFC,0x31,0x8B,0x85,0xF4,0x23,0xDE,0x0D,0xED,0xCB,0x63,0x06,0x9B,0x92,0x04,0x71};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x28,0x43,0x82,0x67,0x79,0x37,0x9E,0x2E,0x79,0x4B,0xB9,0x94,0x38,0xA2,0x26,0x56,0x79,0xEB,0x1E,0x99,0x96,0xC5,0x6E,0x7B,0x70,0x33,0x06,0x66,0xF7,0xB8,0x31,0x03};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^12)*G
			{
				const static sl_uint8 _x[] = {0x17,0x5E,0x15,0x9F,0x72,0x8B,0x86,0x5A,0x72,0xF9,0x9C,0xC6,0xC6,0xFC,0x84,0x6D,0xE0,0xB9,0x38,0x33,0xFD,0x22,0x22,0xED,0x73,0xFC,0xE5,0xB5,0x51,0xE5,0xB7,0x39};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xD3,0x50,0x6E,0x0D,0x9E,0x3C,0x79,0xEB,0xA4,0xEF,0x97,0xA5,0x1F,0xF7,0x1F,0x5E,0xAC,0xB5,0x95,0x5A,0xDD,0x24,0x34,0x5C,0x6E,0xFA,0x6F,0xFE,0xE9,0xFE,0xD6,0x95};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^13)*G
			{
				const static sl_uint8 _x[] = {0x42,0x3A,0x01,0x3F,0x03,0xFF,0x32,0xD7,0xA5,0xFF,0xBC,0xC8,0xE1,0x39,0xC6,0x21,0x30,0xFD,0xFE,0xB5,0xC6,0xDA,0x12,0x1B,0xCE,0x78,0x04,0x9E,0x46,0xBC,0x47,0xD6};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xB9,0x1A,0xE0,0x0F,0xE1,0xE1,0xD9,0x70,0xA1,0x17,0x9F,0x7B,0xBA,0xF6,0xB3,0xC7,0x72,0x0D,0x8E,0xC3,0x52,0x4F,0x00,0x9E,0xD1,0x23,0x6E,0x6D,0x8B,0x54,0x8A,0x34};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^14)*G
			{
				const static sl_uint8 _x[] = {0x11,0x1D,0x6A,0x45,0xAC,0x1F,0xB9,0x05,0x08,0x90,0x7A,0x7A,0xBC,0xD6,0x87,0x76,0x49,0xDF,0x66,0x2F,0x3B,0x3E,0x27,0x41,0x30,0x2D,0xF6,0xF7,0x84,0x16,0x82,0x4A};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x06,0x96,0x91,0x1C,0x47,0x8E,0xAF,0xFB,0xB9,0x0D,0x48,0xDB,0xFF,0x06,0x59,0x52,0xF0,0x70,0x00,0x89,0x96,0xDA,0xCA,0x4C,0xA9,0xA1,0x11,0xD4,0x21,0x08,0xE9,0xD0};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^15)*G
			{
				const static sl_uint8 _x[] = {0x4A,0x4A,0x6D,0xC9,0x7A,0xC7,0xC8,0xB8,0xAD,0x79,0x5D,0xBE,0xBC,0xB9,0xDC,0xFF,0x72,0x90,0xB6,0x8A,0x5E,0xF7,0x4E,0x56,0xAB,0x5E,0xDD,0xE0,0x1B,0xCE,0xD7,0x75};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x52,0x99,0x11,0xB0,0x16,0x63,0x1E,0x72,0x94,0x3E,0xF9,0xF7,0x39,0xC0,0xF4,0x57,0x1D,0xE9,0x0C,0xDB,0x42,0x47,0x42,0xAC,0xB2,0xBF,0x8F,0x68,0xA7,0x8D,0xD6,0x6D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^16)*G
			{
				const static sl_uint8 _x[] = {0x36,0x3D,0x90,0xD4,0x47,0xB0,0x0C,0x9C,0x99,0xCE,0xAC,0x05,0xB6,0x26,0x2E,0xE0,0x53,0x44,0x1C,0x7E,0x55,0x55,0x2F,0xFE,0x52,0x6B,0xAD,0x8F,0x83,0xFF,0x46,0x40};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x04,0xE2,0x73,0xAD,0xFC,0x73,0x22,0x21,0x95,0x3B,0x44,0x53,0x97,0xF3,0x36,0x31,0x45,0xB9,0xA8,0x90,0x08,0x19,0x9E,0xCB,0x62,0x00,0x3C,0x7F,0x3B,0xEE,0x9D,0xE9};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^17)*G
			{
				const static sl_uint8 _x[] = {0x4C,0x1B,0x98,0x66,0xED,0x9A,0x7E,0x9B,0x55,0x39,0x73,0xC6,0xC9,0x3B,0x02,0xBF,0x0B,0x62,0xFB,0x01,0x2E,0xDF,0xB5,0x9D,0xD2,0x71,0x2A,0x5C,0xAF,0x92,0xC5,0x41};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xC1,0xF7,0x92,0xD3,0x20,0xBE,0x8A,0x0F,0x7F,0xBC,0xB7,0x53,0xCE,0x56,0xE6,0x9C,0xC6,0x52,0xEA,0xD7,0xE4,0x3E,0xB1,0xAD,0x72,0xC4,0xF3,0xFD,0xC6,0x8F,0xE0,0x20};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^18)*G
			{
				const static sl_uint8 _x[] = {0xA4,0x08,0x38,0x77,0xBA,0x83,0xB1,0x2B,0x52,0x9A,0x2F,0x3C,0x07,0x80,0xB5,0x4E,0x32,0x33,0xED,0xBC,0x1A,0x28,0xF1,0x35,0xE0,0xC8,0xF2,0x8C,0xBE,0xAA,0xF3,0xD1};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x40,0xE9,0xF6,0x12,0xFE,0xEF,0xBC,0x79,0xB8,0xBF,0x83,0xD6,0x93,0x61,0xB3,0xE2,0x20,0x01,0xE7,0x57,0x6E,0xD1,0xEF,0x90,0xB1,0x2B,0x53,0x4D,0xF0,0xB2,0x54,0xB9};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^19)*G
			{
				const static sl_uint8 _x[] = {0xA8,0x04,0xC6,0x41,0xD2,0x8C,0xC0,0xB5,0x3A,0x4E,0x3E,0x1A,0x2F,0x56,0xC8,0x6F,0x6E,0x0D,0x88,0x0A,0x45,0x42,0x03,0xB9,0x8C,0xD3,0xDB,0x5A,0x79,0x40,0xD3,0x3A};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x95,0xBE,0x83,0x25,0x2B,0x2F,0xA6,0xD0,0x3D,0xEC,0x28,0x42,0xC1,0x60,0x47,0xE8,0x1A,0xF1,0x8C,0xA8,0x9C,0xF7,0x36,0xA9,0x43,0xCE,0x95,0xFA,0x6D,0x46,0x96,0x7A};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^20)*G
			{
				const static sl_uint8 _x[] = {0x8B,0x4B,0x5F,0x16,0x5D,0xF3,0xC2,0xBE,0x8C,0x62,0x44,0xB5,0xB7,0x45,0x63,0x88,0x43,0xE4,0xA7,0x81,0xA1,0x5B,0xCD,0x1B,0x69,0xF7,0x9A,0x55,0xDF,0xFD,0xF8,0x0C};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x4A,0xAD,0x0A,0x6F,0x68,0xD3,0x08,0xB4,0xB3,0xFB,0xD7,0x81,0x3A,0xB0,0xDA,0x04,0xF9,0xE3,0x36,0x54,0x61,0x62,0xEE,0x56,0xB3,0xEF,0xF0,0xC6,0x5F,0xD4,0xFD,0x36};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^21)*G
			{
				const static sl_uint8 _x[] = {0xED,0x0C,0x5C,0xE4,0xE1,0x32,0x91,0x71,0x8C,0xE1,0x7C,0x7E,0xC8,0x3C,0x61,0x10,0x71,0xAF,0x64,0xEE,0x41,0x7C,0x99,0x7A,0xBB,0x3F,0x26,0x71,0x47,0x55,0xE4,0xBE};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x22,0x1A,0x9F,0xC7,0xBC,0x23,0x45,0xBD,0xBF,0x3D,0xAD,0x7F,0x5A,0x7E,0xA6,0x80,0x49,0xD9,0x39,0x25,0x76,0x3D,0xDA,0xB1,0x63,0xF9,0xFA,0x6E,0xA0,0x7B,0xF4,0x2F};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^22)*G
			{
				const static sl_uint8 _x[] = {0xFA,0xEC,0xB0,0x13,0xC4,0x4C,0xE6,0x94,0xB3,0xB1,0x5C,0x3F,0x83,0xF1,0xFA,0xE8,0xE5,0x32,0x54,0x56,0x6E,0x05,0x52,0xCE,0xD4,0xB6,0xE6,0xC8,0x07,0xCE,0xC8,0xAB};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xCC,0x09,0xB5,0xE9,0x0E,0x9E,0xCB,0x57,0xFC,0x2E,0x02,0xC6,0xEC,0x2F,0xB1,0x3D,0x9C,0x32,0xB2,0x86,0xB8,0x5E,0x2E,0x2E,0x89,0x81,0xDF,0xD9,0xAB,0x15,0x50,0x70};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^23)*G
			{
				const static sl_uint8 _x[] = {0x09,0xBB,0x8A,0x13,0x2D,0xCA,0xD2,0xF2,0xC8,0x73,0x1A,0x0B,0x37,0xCB,0xCA,0xFD,0xB3,0xB2,0xDD,0x82,0x4F,0x23,0xCD,0x3E,0x07,0xF6,0x4E,0xAE,0x9A,0xD1,0xB1,0xF7};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x94,0x5B,0xB2,0xB2,0xAF,0xEE,0xE3,0xB9,0xB6,0xF9,0xDD,0x28,0x4F,0x86,0x3E,0x85,0x0F,0x54,0xA8,0x40,0xF4,0x75,0x2D,0x53,0x64,0x13,0x06,0x27,0xC3,0x81,0x1C,0x80};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^24)*G
			{
				const static sl_uint8 _x[] = {0x72,0x3C,0xBA,0xA6,0xE5,0xDB,0x99,0x6D,0x6B,0xF7,0x71,0xC0,0x0B,0xD5,0x48,0xC7,0xB7,0x00,0xDB,0xFF,0xA6,0xC0,0xE7,0x7B,0xCB,0x61,0x15,0x92,0x52,0x32,0xFC,0xDA};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x96,0xE8,0x67,0xB5,0x59,0x5C,0xC4,0x98,0xA9,0x21,0x13,0x74,0x88,0x82,0x4D,0x6E,0x26,0x60,0xA0,0x65,0x37,0x79,0x49,0x48,0x01,0xDC,0x06,0x9D,0x9E,0xB3,0x9F,0x5F};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^25)*G
			{
				const static sl_uint8 _x[] = {0x57,0xEF,0xA7,0x86,0x43,0x7B,0x74,0x4D,0x34,0x3D,0x7D,0xC4,0x57,0x73,0xA3,0xC6,0x2D,0x24,0x0A,0x43,0x07,0x98,0x49,0x07,0x1F,0xD3,0x83,0xD6,0x0C,0xA0,0x30,0xD5};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xD7,0x12,0xDB,0x0B,0xD1,0xB4,0x85,0x18,0x89,0x36,0x27,0xC9,0x28,0xDE,0x03,0xEC,0x68,0x9B,0x6D,0x2A,0xE5,0xE9,0x97,0x4A,0xB0,0x7A,0xB4,0x42,0x74,0xB0,0x2F,0x9E};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^26)*G
			{
				const static sl_uint8 _x[] = {0x26,0x4B,0xBD,0x43,0x6A,0x28,0xBC,0x42,0xA2,0xDF,0x7E,0x9C,0xD5,0x22,0x6C,0xB9,0x10,0x80,0x57,0x7E,0x32,0x7B,0x01,0x2A,0x7F,0xAF,0xC7,0x77,0x0C,0x58,0x4D,0xD5};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xD8,0x7C,0x6F,0xA9,0x4E,0xE0,0x93,0xB4,0xD4,0xF7,0x5C,0xE2,0x4C,0x33,0xBE,0x22,0x6A,0x11,0x82,0x43,0x71,0x7B,0x8D,0x8D,0xE6,0x12,0x27,0x93,0x77,0x04,0xAB,0x11};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^27)*G
			{
				const static sl_uint8 _x[] = {0xA9,0x4C,0x65,0x24,0xBD,0x40,0xD2,0xBB,0xDA,0xC8,0x5C,0x05,0x62,0x36,0xA7,0x9D,0xA7,0x8B,0xC6,0x1F,0xD5,0xBD,0xEC,0x9D,0x2B,0xF2,0x6B,0xD8,0x4B,0x24,0x38,0xE8};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xB5,0x20,0x1F,0xD9,0x92,0xF9,0x62,0x80,0xFD,0x79,0x21,0x95,0x05,0x01,0x9E,0x3A,0x7E,0x5D,0x3C,0x60,0xA0,0xE3,0x9B,0x2B,0xC2,0xE2,0xC8,0xDB,0xF1,0x86,0x61,0xF4};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^28)*G
			{
				const static sl_uint8 _x[] = {0xEE,0xBF,0xA4,0xD4,0x93,0xBE,0xBF,0x98,0xBA,0x5F,0xEE,0xC8,0x12,0xC2,0xD3,0xB5,0x09,0x47,0x96,0x12,0x37,0xA9,0x19,0x83,0x9A,0x53,0x3E,0xCA,0x0E,0x7D,0xD7,0xFA};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x5D,0x9A,0x8C,0xA3,0x97,0x0E,0xF0,0xF2,0x69,0xEE,0x7E,0xDA,0xF1,0x78,0x08,0x9D,0x9A,0xE4,0xCD,0xC3,0xA7,0x11,0xF7,0x12,0xDD,0xFD,0x4F,0xDA,0xE1,0xDE,0x89,0x99};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^29)*G
			{
				const static sl_uint8 _x[] = {0x38,0x1C,0x4A,0xD7,0xA7,0xA9,0x7B,0xFD,0xA6,0x1C,0x60,0x31,0xC1,0x18,0x49,0x5F,0xC4,0xEA,0x4B,0xC0,0x8F,0x67,0x66,0xD6,0x76,0xBE,0xE9,0x08,0x47,0xD2,0x97,0xFD};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x93,0x6A,0xF5,0x3B,0x23,0x8E,0xEE,0xE4,0x8F,0x3E,0x5F,0xA7,0x09,0x91,0x5E,0xCC,0xF0,0x45,0x10,0x32,0xDB,0x93,0x9C,0x00,0x93,0xAC,0xE3,0x18,0x7D,0x49,0x3F,0xC5};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^30)*G
			{
				const static sl_uint8 _x[] = {0xE1,0xEF,0xB9,0xCD,0x05,0xAD,0xC6,0x3B,0xCC,0xE1,0x08,0x31,0xD9,0x53,0x8C,0x47,0x9C,0xF1,0xD0,0x5F,0xEF,0xDD,0x08,0xB2,0x44,0x8D,0x70,0x42,0x2E,0xDE,0x45,0x4C};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x0E,0xCB,0x45,0x30,0xD8,0xAF,0x9B,0xE7,0xB0,0x15,0x4C,0x1F,0xFE,0x47,0x71,0x23,0x46,0x4E,0x32,0x44,0xA7,0xA2,0xD4,0xC6,0xAD,0x9F,0xD2,0x33,0xA8,0x91,0x37,0x97};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^31)*G
			{
				const static sl_uint8 _x[] = {0x53,0x18,0xF9,0xB1,0xA2,0x69,0x70,0x10,0xC5,0xAC,0x23,0x5E,0x9A,0xF4,0x75,0xA8,0xC7,0xE5,0x41,0x9F,0x33,0xD4,0x7B,0x18,0xD3,0x3F,0xEE,0xB3,0x29,0xEB,0x99,0xA4};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xF4,0x4C,0xCF,0xEB,0x4B,0xED,0xA4,0x19,0x57,0x72,0xD9,0x3A,0xEB,0xB4,0x05,0xE8,0xA4,0x1F,0x2B,0x40,0xD1,0xE3,0xEC,0x65,0x2C,0x72,0x6E,0xEE,0xFE,0x91,0xF9,0x2D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^32)*G
			{
				const static sl_uint8 _x[] = {0x10,0x0F,0x44,0xDA,0x69,0x6E,0x71,0x67,0x27,0x91,0xD0,0xA0,0x9B,0x7B,0xDE,0x45,0x9F,0x12,0x15,0xA2,0x9B,0x3C,0x03,0xBF,0xEF,0xD7,0x83,0x5B,0x39,0xA4,0x8D,0xB0};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xCD,0xD9,0xE1,0x31,0x92,0xA0,0x0B,0x77,0x2E,0xC8,0xF3,0x30,0x0C,0x09,0x06,0x66,0xB7,0xFF,0x4A,0x18,0xFF,0x51,0x95,0xAC,0x0F,0xBD,0x5C,0xD6,0x2B,0xC6,0x5A,0x09};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^33)*G
			{
				const static sl_uint8 _x[] = {0x8C,0x09,0x89,0xF2,0xCE,0xB5,0xC7,0x71,0xA8,0x41,0x5D,0xFF,0x2B,0x4C,0x41,0x99,0xD8,0xD9,0xC8,0xF9,0x23,0x7D,0x08,0x08,0x4B,0x05,0x28,0x4F,0x1E,0x4D,0xF7,0x06};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xFB,0x4D,0xBD,0x04,0x4F,0x43,0x20,0x34,0xFF,0xD2,0x17,0x2C,0xB9,0xDC,0x96,0x6C,0x60,0xDE,0x6B,0xF5,0x15,0x65,0x11,0xAA,0x73,0x6A,0xC5,0xA3,0x5D,0x72,0xFA,0x98};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^34)*G
			{
				const static sl_uint8 _x[] = {0xFB,0x8F,0x15,0x3C,0x5E,0x26,0x67,0x04,0xC4,0xA4,0x81,0x74,0x32,0x62,0xC0,0x25,0x9C,0x52,0x85,0x39,0xBC,0x95,0xBC,0x1B,0xB1,0xE6,0x3C,0x33,0xDC,0x47,0xBF,0xFD};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x6C,0xA2,0x7A,0x9D,0xC5,0xE0,0x62,0x18,0x16,0xFA,0x11,0xD9,0xB4,0xBC,0xCD,0x53,0x1D,0xDE,0x13,0x89,0xAC,0x54,0x26,0x13,0x09,0x0A,0x45,0xDD,0xD9,0x49,0xB0,0x95};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^35)*G
			{
				const static sl_uint8 _x[] = {0xE7,0x47,0x33,0x3F,0xD7,0x5D,0x51,0x75,0x5A,0x0C,0xC9,0xF0,0xA7,0x28,0x70,0x84,0x65,0xA0,0x2C,0x58,0x77,0x37,0xA7,0xB8,0xB8,0xFA,0x1B,0x8B,0x4B,0xB2,0x62,0x9A};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xF2,0xAF,0xFE,0x01,0x45,0x07,0x0C,0x11,0x4C,0xC4,0x36,0x03,0x80,0x4C,0x25,0x81,0xC8,0x83,0x76,0xAA,0x6E,0x1A,0x96,0x9A,0x9F,0x8D,0x96,0x1A,0x69,0x46,0xF6,0xD6};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^36)*G
			{
				const static sl_uint8 _x[] = {0xE1,0x03,0x1B,0xE2,0x62,0xC7,0xED,0x1B,0x1D,0xC9,0x22,0x7A,0x4A,0x04,0xC0,0x17,0xA7,0x7F,0x8D,0x44,0x64,0xF3,0xB3,0x85,0x2C,0x8A,0xCD,0xE6,0xE5,0x34,0xFD,0x2D};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x9D,0x70,0x61,0x92,0x89,0x40,0x40,0x5E,0x6B,0xB6,0xA4,0x17,0x65,0x97,0x53,0x5A,0xF2,0x92,0xDD,0x41,0x9E,0x1C,0xED,0x79,0xA4,0x4F,0x18,0xF2,0x94,0x56,0xA0,0x0D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^37)*G
			{
				const static sl_uint8 _x[] = {0xF4,0xB9,0x3F,0x22,0x4C,0x80,0x89,0xEA,0xB9,0xF9,0x5D,0xCD,0x0F,0x29,0xB2,0xC9,0x02,0x8A,0x6A,0xC5,0xDE,0x94,0xD8,0x57,0x84,0xE2,0x7E,0x36,0xA9,0x5C,0x83,0x56};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xA6,0x7A,0x92,0xEC,0x06,0x29,0x62,0xDF,0xB0,0xE5,0xF6,0xA7,0xA4,0x0E,0xEE,0x90,0xC3,0x7E,0xF1,0x34,0x49,0x15,0x60,0x9A,0xBD,0x58,0x61,0xB9,0xBE,0x00,0x1F,0xD3};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^38)*G
			{
				const static sl_uint8 _x[] = {0x09,0xD1,0xAC,0xA1,0xFC,0xE5,0x52,0x36,0xB1,0x96,0x22,0xEA,0x02,0x5B,0x08,0xB0,0xD5,0x1E,0x85,0x12,0xF9,0x7E,0x69,0x6C,0x20,0xD6,0x2F,0xE1,0x7B,0x16,0x0E,0x8A};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x11,0x53,0x18,0x8F,0x51,0x01,0xF0,0xC6,0x3E,0x56,0x69,0x2C,0xE0,0xD8,0xC2,0x7E,0x6F,0xE9,0xE0,0xEE,0x92,0x12,0xB5,0xE5,0x34,0xE0,0x50,0xC5,0x7C,0xA0,0x4C,0x44};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^39)*G
			{
				const static sl_uint8 _x[] = {0xC6,0x6C,0x59,0xCC,0x45,0x4C,0x2B,0x9E,0x18,0xA2,0xAD,0x79,0x38,0x21,0xCD,0xE7,0x51,0x8B,0x3A,0x93,0xBF,0xC3,0x95,0x62,0xE9,0x7D,0x7D,0x04,0x75,0xBA,0x7F,0xC2};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xD9,0x59,0x2F,0xE2,0xBF,0xB3,0x0F,0xCF,0xBE,0xA4,0xF3,0xCE,0xAA,0xC1,0x0C,0xB2,0xF0,0x0A,0x60,0xDD,0xB1,0x59,0x55,0x97,0x7E,0xC3,0xC6,0x9C,0xF7,0x5F,0x59,0x56};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^40)*G
			{
				const static sl_uint8 _x[] = {0xFE,0xEA,0x6C,0xAE,0x46,0xD5,0x5B,0x53,0x0A,0xC2,0x83,0x9F,0x14,0x3B,0xD7,0xEC,0x5C,0xF8,0xB2,0x66,0xA4,0x1D,0x6A,0xF5,0x2D,0x5E,0x68,0x8D,0x90,0x94,0x69,0x6D};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xE5,0x7C,0x6B,0x6C,0x97,0xDC,0xE1,0xBA,0xB0,0x6E,0x4E,0x12,0xBF,0x3E,0xCD,0x5C,0x98,0x1C,0x89,0x57,0xCC,0x41,0x44,0x2D,0x31,0x55,0xDE,0xBF,0x18,0x09,0x00,0x88};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^41)*G
			{
				const static sl_uint8 _x[] = {0x4D,0x00,0x0B,0x62,0x1A,0xDB,0x87,0xE1,0xC5,0x32,0x61,0xAF,0x9D,0xB2,0xE1,0x79,0x14,0x1E,0xCA,0xE0,0xB3,0x31,0xA1,0x87,0x0A,0xA4,0x04,0x0A,0xEE,0x75,0x2B,0x08};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x6A,0x0D,0x5B,0x8F,0x18,0xE0,0xD2,0x55,0xCB,0x6D,0x82,0x55,0x82,0xD9,0x72,0xCC,0xCB,0x7D,0xF5,0xF1,0x19,0xC7,0x29,0x3A,0x3E,0x72,0x85,0x1F,0x48,0x30,0x2C,0xEA};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^42)*G
			{
				const static sl_uint8 _x[] = {0x71,0xF5,0x70,0xCA,0x20,0x3D,0xA0,0x5D,0xD6,0xAA,0x26,0x21,0x14,0x71,0x71,0x28,0xD6,0x57,0xA0,0x40,0x3E,0x1F,0x1B,0x77,0xF8,0x99,0x62,0xFD,0x47,0x5C,0x58,0xEF};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xEB,0x42,0x41,0x5B,0x95,0xDC,0x88,0x0D,0xD2,0x55,0x57,0x34,0x5B,0xC9,0x5B,0x8D,0xF2,0x44,0x5D,0x00,0xC3,0x36,0x3E,0x7D,0xF8,0x64,0x9A,0x72,0xD3,0x5D,0x42,0x0E};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^43)*G
			{
				const static sl_uint8 _x[] = {0xA2,0xB7,0xB3,0x62,0x9F,0x7B,0xD2,0x53,0xB7,0xD2,0x82,0xB5,0xC2,0x1D,0xA0,0x14,0x46,0xB4,0x82,0x1D,0xC6,0x5E,0x76,0x51,0x60,0x48,0xB0,0x60,0x43,0xFF,0x83,0x59};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x69,0x30,0x38,0x94,0x16,0x95,0x12,0x2D,0x57,0xA9,0x37,0xA3,0xF7,0x1E,0x29,0xC9,0x10,0xD1,0x08,0x35,0x04,0x6F,0x38,0x35,0xA2,0x39,0x7F,0xEC,0xFE,0x86,0xFE,0xC2};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^44)*G
			{
				const static sl_uint8 _x[] = {0xDA,0x67,0xA9,0x1D,0x91,0x04,0x9C,0xDC,0xB3,0x67,0xBE,0x4B,0xE6,0xFF,0xCA,0x3C,0xFE,0xED,0x65,0x7D,0x80,0x85,0x83,0xDE,0x33,0xFA,0x97,0x8B,0xC1,0xEC,0x6C,0xB1};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x9B,0xAC,0xAA,0x35,0x48,0x16,0x42,0xBC,0x41,0xF4,0x63,0xF7,0xEC,0x97,0x80,0xE5,0xDE,0xC7,0xAD,0xC5,0x08,0xF7,0x40,0xA1,0x7E,0x9E,0xA8,0xE2,0x7A,0x68,0xBE,0x1D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^45)*G
			{
				const static sl_uint8 _x[] = {0x4D,0xBA,0xCD,0x36,0x5F,0xA1,0xEF,0x58,0x7C,0x0C,0x0C,0xFA,0xAF,0x00,0xD8,0x71,0x8B,0xBD,0x9F,0x35,0xCC,0xEA,0x5A,0x83,0x5E,0xE3,0xCC,0x82,0x1F,0xE7,0x41,0xC9};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x16,0xC3,0x54,0x0E,0x8A,0x51,0x89,0x2E,0x7F,0xDC,0xFD,0x59,0xE8,0x38,0x29,0x9D,0x0C,0xC3,0x84,0xA0,0x9F,0xC0,0x53,0x5F,0x60,0xBE,0x10,0xF8,0x33,0x8E,0xB6,0x23};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^46)*G
			{
				const static sl_uint8 _x[] = {0x13,0xD1,0xFF,0xC4,0x81,0x50,0x9B,0xEE,0xE6,0x8F,0x17,0xD8,0xFF,0x41,0xC2,0x59,0x0F,0x4C,0x85,0xF1,0x52,0x68,0x60,0x50,0x87,0xED,0xA8,0xBA,0xB4,0xE2,0x18,0xDA};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x60,0x08,0x39,0x1F,0xA9,0x91,0x96,0x1D,0xCE,0xCB,0x93,0x37,0xB1,0xB7,0x58,0xBD,0xA4,0xAD,0x01,0x20,0x6D,0x5B,0xD1,0x27,0xE0,0xDB,0x41,0x9D,0xDB,0x19,0x1C,0x19};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^47)*G
			{
				const static sl_uint8 _x[] = {0x21,0x9B,0x4F,0x9C,0xEF,0x6C,0x60,0x00,0x76,0x59,0xC7,0x9C,0x45,0xB0,0x53,0x3B,0x3C,0xC9,0xD9,0x16,0xCE,0x29,0xDB,0xFF,0x13,0x3B,0x40,0xCA,0xA2,0xE9,0x6D,0xB8};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x24,0xD9,0xC6,0x05,0xD9,0x59,0xEF,0xEA,0xF5,0xA4,0x41,0x80,0xC0,0x37,0x2A,0x6E,0x39,0x4F,0x8A,0xC5,0x3E,0x90,0x57,0x65,0x27,0xDF,0x01,0xA7,0x8D,0x3B,0x6B,0xC7};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^48)*G
			{
				const static sl_uint8 _x[] = {0x53,0x90,0x4F,0xAA,0x0B,0x33,0x4C,0xDD,0xA6,0xE0,0x00,0x93,0x5E,0xF2,0x21,0x51,0xEC,0x08,0xD0,0xF7,0xBB,0x11,0x06,0x9F,0x57,0x54,0x5C,0xCC,0x1A,0x37,0xB7,0xC0};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x5B,0xC0,0x87,0xD0,0xBC,0x80,0x10,0x6D,0x88,0xC9,0xEC,0xCA,0xC2,0x0D,0x3C,0x1C,0x13,0x99,0x99,0x81,0xE1,0x44,0x34,0x69,0x9D,0xCB,0x09,0x6B,0x02,0x27,0x71,0xC8};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^49)*G
			{
				const static sl_uint8 _x[] = {0x01,0xA5,0x75,0xAF,0x9D,0x41,0x46,0x75,0x3C,0xF9,0x91,0x19,0x63,0x16,0x99,0x5D,0x2A,0x6E,0xE7,0xAA,0xAD,0x0F,0x85,0xAD,0x57,0xCD,0x0F,0x1F,0x38,0xA4,0x7C,0xA9};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x30,0x38,0xF1,0xCB,0x8A,0xB2,0x0D,0xC3,0xCC,0x55,0xFC,0x52,0xE1,0xBB,0x86,0x98,0xBD,0xB9,0x3C,0x5D,0x9F,0x4D,0x7E,0xA6,0x67,0xC5,0xDF,0x2E,0x77,0xEB,0xCD,0xB7};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^50)*G
			{
				const static sl_uint8 _x[] = {0xF5,0xF0,0xE0,0x43,0x76,0x21,0xD4,0x39,0xCA,0x71,0xF5,0xC1,0xB7,0x61,0x55,0xD6,0xD3,0xA6,0x1A,0x83,0xD3,0xC2,0x0C,0x6E,0xE3,0x09,0xD7,0x55,0xE3,0x15,0x56,0x5B};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x6B,0x9F,0x4E,0x62,0xBE,0x5A,0x05,0x2B,0xF6,0x21,0x89,0x16,0x0D,0xF7,0x10,0x1A,0xA5,0xBF,0x61,0xBF,0x3E,0xD7,0xE4,0x0A,0x67,0x84,0x30,0xAF,0xDD,0x2E,0xCC,0x82};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^51)*G
			{
				const static sl_uint8 _x[] = {0x8F,0x50,0x6F,0x0B,0x6C,0x0B,0x6E,0x9A,0x57,0xA7,0xF3,0x6D,0x97,0x0C,0xA4,0xE3,0x47,0xCB,0xC9,0x21,0x46,0x22,0x76,0x42,0xCB,0xE7,0x81,0xD9,0xF5,0x36,0x2D,0x33};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x46,0x9F,0x95,0x5D,0x2A,0xFA,0x61,0x71,0x95,0x30,0xC5,0x42,0x4F,0x1C,0x33,0x68,0x48,0xCF,0x92,0x5D,0x43,0xBB,0x8E,0xAF,0x30,0x48,0x7D,0x0C,0x87,0xFA,0x24,0x3F};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^52)*G
			{
				const static sl_uint8 _x[] = {0x8E,0x7B,0xCD,0x0B,0xD3,0x59,0x83,0xA7,0x71,0x9C,0xCA,0x77,0x64,0xCA,0x90,0x67,0x79,0xB5,0x3A,0x04,0x3A,0x9B,0x8B,0xCA,0xEF,0xF9,0x59,0xF4,0x3A,0xD8,0x60,0x47};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x10,0xB7,0x77,0x0B,0x2A,0x3D,0xA4,0xB3,0x94,0x03,0x10,0x42,0x0C,0xA9,0x51,0x45,0x79,0xE8,0x8E,0x2E,0x47,0xFD,0x68,0xB3,0xEA,0x10,0x04,0x7E,0x84,0x60,0x37,0x2A};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^53)*G
			{
				const static sl_uint8 _x[] = {0x33,0xB3,0x5B,0xAA,0x19,0x5E,0x72,0x9D,0xC3,0x50,0xF3,0x19,0x99,0x69,0x50,0xDF,0x3B,0xC1,0x5B,0x8D,0x3D,0x03,0x89,0xE7,0x77,0xD2,0x80,0x8B,0xF1,0x3F,0x03,0x51};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xA5,0x8A,0x01,0x85,0x64,0x0A,0xBF,0x87,0xF9,0x46,0x40,0x36,0x24,0x8D,0x52,0xBC,0xAA,0x65,0x60,0xEF,0xBC,0x88,0x9B,0x70,0x2B,0xC5,0x03,0xCC,0xCB,0x8D,0x74,0x18};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^54)*G
			{
				const static sl_uint8 _x[] = {0x37,0x4D,0xEE,0xAE,0x22,0xC9,0x3F,0x95,0x5C,0xB8,0x3A,0xD2,0x07,0x1F,0x7E,0x22,0x56,0xF6,0xE1,0x09,0xCA,0xD7,0xBC,0xA6,0xD7,0x1D,0xC7,0xB2,0x44,0x14,0xBB,0x36};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x17,0x11,0x65,0xB6,0x4F,0xCD,0x4F,0x99,0x16,0x03,0x2C,0x06,0xF8,0x06,0xF7,0x29,0x38,0x28,0xD6,0x63,0x00,0xE5,0x43,0x21,0x78,0x75,0xBE,0xA9,0x8D,0xAF,0x73,0x4A};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^55)*G
			{
				const static sl_uint8 _x[] = {0x23,0x80,0xC0,0x9C,0x7F,0x3A,0xEA,0xE5,0x7C,0x46,0xE0,0x73,0x95,0xAE,0xB0,0xDC,0x94,0x4D,0xBA,0xF2,0xB6,0x2A,0x9F,0x0C,0x5E,0x8A,0x64,0xAD,0x6A,0xE7,0xD6,0x16};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x6F,0x8E,0x86,0x19,0x34,0x64,0x95,0x6A,0xF1,0x59,0x8A,0xEF,0xD5,0x09,0xB0,0x9A,0x93,0xAF,0x92,0x14,0x8F,0x84,0x67,0x56,0x00,0x99,0xBE,0x48,0x16,0x1B,0xBC,0x1A};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^56)*G
			{
				const static sl_uint8 _x[] = {0x38,0x5E,0xED,0x34,0xC1,0xCD,0xFF,0x21,0xE6,0xD0,0x81,0x86,0x89,0xB8,0x1B,0xDE,0x71,0xA7,0xF4,0xF1,0x83,0x97,0xE6,0x69,0x0A,0x84,0x1E,0x15,0x99,0xC4,0x38,0x62};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x28,0x3B,0xEB,0xC3,0xE8,0xEA,0x23,0xF5,0x67,0x01,0xDE,0x19,0xE9,0xEB,0xF4,0x57,0x6B,0x30,0x4E,0xEC,0x20,0x86,0xDC,0x8C,0xC0,0x45,0x8F,0xE5,0x54,0x2E,0x54,0x53};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^57)*G
			{
				const static sl_uint8 _x[] = {0xF6,0xF6,0x22,0x08,0x3D,0xAF,0x54,0x80,0x04,0x56,0xBE,0x13,0x4D,0x5F,0x67,0xD1,0x47,0xC8,0x26,0x42,0xBE,0xFC,0x1C,0xE2,0xDC,0x83,0xA2,0x70,0x78,0xF2,0x82,0x7C};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x1B,0xCD,0x4E,0x81,0x7D,0xE7,0x3A,0x0F,0xAF,0x2C,0x57,0x15,0xB3,0x67,0xCE,0xE7,0xE6,0x57,0xCA,0x74,0x48,0x32,0x1B,0xF6,0xD1,0x5B,0x20,0xB5,0x20,0xAA,0xA1,0x02};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^58)*G
			{
				const static sl_uint8 _x[] = {0xFB,0x26,0xE5,0x18,0x8F,0x95,0x3D,0xE2,0xBD,0x70,0xCB,0x3C,0x3D,0x1F,0xC2,0x55,0xCD,0x91,0xC3,0xCE,0x7D,0x8C,0x6F,0x36,0x9D,0x89,0x32,0x09,0x71,0x5A,0xDC,0xB6};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xF3,0xE1,0x28,0x81,0x10,0x12,0xA3,0x4D,0x58,0xE8,0x46,0xA7,0x19,0xD0,0x17,0x69,0x16,0xD2,0xCB,0x31,0xB8,0xB7,0xAB,0x54,0x49,0xDB,0xCA,0x3B,0x58,0xBA,0x68,0xF3};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^59)*G
			{
				const static sl_uint8 _x[] = {0x89,0x91,0x22,0x59,0x11,0xB9,0x13,0x2D,0x28,0xF5,0xC6,0xBC,0x76,0x3C,0xEA,0xB7,0xD1,0x8C,0x37,0x06,0x0E,0x8B,0xD1,0xD7,0xED,0x44,0xDB,0x75,0x60,0x78,0x8C,0x1E};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xDA,0x8B,0x4D,0x98,0x7C,0xC9,0xAC,0x9B,0x27,0xB8,0x76,0x35,0x59,0xB1,0x36,0xFA,0x36,0x96,0x9C,0x84,0xFD,0xEF,0x9E,0x11,0x63,0x5C,0x42,0x22,0x8E,0x8F,0x0E,0xF1};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^60)*G
			{
				const static sl_uint8 _x[] = {0x06,0xF9,0xD9,0xB8,0x03,0xEC,0xF1,0x91,0x63,0x7C,0x73,0xA4,0x41,0x3D,0xFA,0x18,0x0F,0xDD,0xF8,0x4A,0x59,0x47,0xFB,0xC9,0xC6,0x06,0xED,0x86,0xC3,0xFA,0xC3,0xA7};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x7C,0x80,0xC6,0x8E,0x60,0x30,0x59,0xBA,0x69,0xB8,0xE2,0xA3,0x0E,0x45,0xC4,0xD4,0x7E,0xA4,0xDD,0x2F,0x5C,0x28,0x10,0x02,0xD8,0x68,0x90,0x60,0x3A,0x84,0x21,0x60};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^61)*G
			{
				const static sl_uint8 _x[] = {0xAE,0x86,0xEE,0xEA,0x25,0x2B,0x41,0x1C,0x1C,0xDC,0x36,0xC2,0x84,0x48,0x29,0x39,0xDA,0x17,0x45,0xE5,0xA7,0xE4,0xDA,0x17,0x5C,0x9D,0x22,0x74,0x4B,0x7F,0xD7,0x2D};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x19,0xE9,0x93,0xC9,0x70,0x73,0x02,0xF9,0x62,0xAB,0x0A,0xCE,0x58,0x9F,0xF0,0xE9,0x8D,0x92,0x11,0x55,0x14,0x72,0xF7,0x28,0x23,0x34,0xCB,0x7A,0x4E,0xEE,0x38,0xBC};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^62)*G
			{
				const static sl_uint8 _x[] = {0x22,0x48,0xC9,0xF9,0x0B,0xBF,0xFF,0x55,0xE6,0x1D,0x2F,0x8C,0x56,0xDC,0x2C,0x48,0x87,0x18,0xBE,0x75,0xCF,0x36,0xF2,0xEE,0x7A,0x14,0x74,0x26,0x7C,0x16,0x92,0x90};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xFA,0x05,0x94,0x69,0x2D,0x21,0xEE,0xD7,0xA5,0x06,0xBB,0x55,0xB4,0x35,0xBA,0x18,0xE1,0x63,0x75,0x02,0x35,0xDA,0x2B,0xE2,0x36,0x9D,0x8A,0x12,0x88,0x3E,0xA2,0x57};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^63)*G
			{
				const static sl_uint8 _x[] = {0xE1,0x1A,0x6E,0x16,0xE0,0x5C,0x44,0x07,0x4A,0xC1,0x1B,0x48,0xD9,0x40,0x85,0xD0,0xA9,0x9F,0x08,0x77,0xDD,0x1C,0x6F,0x76,0xFD,0x0D,0xAC,0x4B,0xB5,0x09,0x64,0xE3};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x87,0xD6,0x06,0x5B,0x87,0xA2,0xD4,0x30,0xE1,0xAD,0x5E,0x25,0x96,0xF0,0xAF,0x24,0x17,0xAD,0xC6,0xE1,0x38,0x31,0x8C,0x6F,0x76,0x7F,0xBF,0x8B,0x06,0x82,0xBF,0xC8};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^64)*G
			{
				const static sl_uint8 _x[] = {0x33,0x22,0xD4,0x01,0x24,0x3C,0x4E,0x25,0x82,0xA2,0x14,0x7C,0x10,0x4D,0x6E,0xCB,0xF7,0x74,0xD1,0x63,0xDB,0x0F,0x5E,0x53,0x13,0xB7,0xE0,0xE7,0x42,0xD0,0xE6,0xBD};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x56,0xE7,0x07,0x97,0xE9,0x66,0x4E,0xF5,0xBF,0xB0,0x19,0xBC,0x4D,0xDA,0xF9,0xB7,0x28,0x05,0xF6,0x3E,0xA2,0x87,0x3A,0xF6,0x24,0xF3,0xA2,0xE9,0x6C,0x28,0xB2,0xA0};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^65)*G
			{
				const static sl_uint8 _x[] = {0x8D,0x26,0x20,0x02,0x50,0xCE,0xBD,0xAE,0x12,0x0E,0xF3,0x1B,0x04,0xC8,0x0C,0xD5,0x0D,0x4C,0xDD,0xC8,0xEA,0xDB,0xCF,0x29,0xFC,0x69,0x6D,0x32,0xC0,0xAD,0xE4,0x62};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xEB,0xED,0x3B,0xB4,0x71,0x5B,0xF4,0x37,0xD3,0x1F,0x6F,0x2D,0xC3,0xEE,0x36,0xBA,0x1D,0x4A,0xFB,0x4E,0x72,0x67,0x8B,0x3A,0xD8,0xE0,0xA8,0xB9,0x0F,0x26,0x47,0x0C};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^66)*G
			{
				const static sl_uint8 _x[] = {0x12,0x38,0xC0,0x76,0x6E,0xAE,0xBE,0xA9,0xCE,0x40,0x68,0xA1,0xF5,0x94,0xD0,0x3B,0x8E,0xD4,0x93,0x0D,0x07,0x2D,0x9C,0x8B,0x91,0x64,0x64,0x3E,0x15,0x16,0xE6,0x33};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x8A,0x9D,0xB0,0x2D,0xBB,0x27,0x13,0x59,0xD6,0xC9,0x79,0xE2,0xD1,0xC3,0xDC,0x17,0x09,0x46,0x25,0x2D,0xCC,0x74,0x02,0x28,0x05,0xCD,0xB7,0x28,0xC7,0x7B,0x78,0x05};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^67)*G
			{
				const static sl_uint8 _x[] = {0x27,0x1D,0x5B,0x07,0x70,0xCB,0x9C,0x15,0xE7,0xB2,0xEA,0x75,0x8A,0x6A,0x11,0xB9,0xCD,0xDC,0xD7,0x28,0x2B,0x0E,0xC2,0x16,0x19,0xB0,0x15,0x52,0x78,0x8E,0x7A,0x66};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x5D,0x3A,0xA4,0x58,0x34,0xE7,0xF4,0x91,0xE4,0x57,0xD0,0x99,0x49,0xAC,0x87,0x7F,0xE2,0xA0,0x65,0xE3,0x50,0x8A,0x82,0x4E,0x7A,0x8D,0x72,0x58,0xE0,0x3C,0x97,0x27};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^68)*G
			{
				const static sl_uint8 _x[] = {0x85,0x67,0x2C,0x7D,0x2D,0xE0,0xB7,0xDA,0x2B,0xD1,0x77,0x0D,0x89,0x66,0x58,0x68,0x74,0x1B,0x3F,0x9A,0xF7,0x64,0x33,0x97,0x72,0x1D,0x74,0xD2,0x81,0x34,0xAB,0x83};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x7C,0x48,0x1B,0x9B,0x5B,0x43,0xB2,0xEB,0x63,0x74,0x04,0x9B,0xFA,0x62,0xC2,0xE5,0xE7,0x7F,0x17,0xFC,0xC5,0x29,0x8F,0x44,0xC8,0xE3,0x09,0x4F,0x79,0x03,0x13,0xA6};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^69)*G
			{
				const static sl_uint8 _x[] = {0x53,0x4C,0xCF,0x6B,0x74,0x0F,0x9E,0xC0,0x36,0xC1,0x86,0x12,0x15,0xC8,0xA6,0x1F,0x3B,0x89,0xEA,0x46,0xDF,0x2E,0x6D,0x96,0x99,0x8B,0x90,0xBC,0x1F,0x17,0xFC,0x25};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xD5,0x71,0x5C,0xB0,0x9C,0x8B,0x2D,0xDB,0x46,0x2A,0xE3,0xDD,0x32,0xD5,0x43,0x55,0x0A,0xE3,0xD2,0x77,0xBF,0xDD,0x28,0xDD,0xD7,0x1C,0x7F,0x6E,0xCF,0xE8,0x6E,0x76};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^70)*G
			{
				const static sl_uint8 _x[] = {0xA9,0x1D,0x1F,0x5C,0xEE,0x87,0xB7,0xF3,0x08,0x1E,0x14,0x20,0x18,0xF8,0xAA,0xED,0x79,0x02,0x0D,0x47,0xEC,0xFB,0xC8,0xD2,0xC7,0x17,0x09,0x23,0xE8,0xBE,0xE8,0xB6};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x74,0x8A,0x32,0x4E,0xE2,0xDF,0x8E,0xE1,0x5A,0x71,0x89,0xC8,0xDD,0xDA,0xD3,0xB2,0xF8,0x00,0x56,0x9F,0x62,0x8C,0xB2,0x25,0x00,0x3D,0x16,0xAA,0x41,0x06,0x44,0xC1};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^71)*G
			{
				const static sl_uint8 _x[] = {0xC1,0x5C,0x8C,0x23,0xD9,0x0C,0x8E,0x35,0xC1,0xA2,0x14,0xDD,0xE2,0xD4,0x38,0x3C,0x07,0x35,0xAE,0x45,0xBE,0xF6,0x1F,0x10,0xAA,0x1A,0x1C,0x25,0x59,0x84,0xCF,0x74};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x2B,0xA9,0x54,0xD8,0x28,0x52,0x22,0x35,0xC8,0xDC,0x6F,0x45,0xE2,0x5F,0xD7,0xBA,0x47,0xBF,0x77,0x2D,0x50,0xB0,0x15,0xA2,0xC4,0xA4,0x8C,0xD8,0x39,0xCC,0xB0,0x00};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^72)*G
			{
				const static sl_uint8 _x[] = {0x09,0x48,0xBF,0x80,0x9B,0x19,0x88,0xA4,0x6B,0x06,0xC9,0xF1,0x91,0x94,0x13,0xB1,0x0F,0x92,0x26,0xC6,0x0F,0x66,0x88,0x32,0xFF,0xD9,0x59,0xAF,0x60,0xC8,0x2A,0x0A};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x53,0xA5,0x62,0x85,0x6D,0xCB,0x66,0x46,0xDC,0x6B,0x74,0xC5,0xD1,0xC3,0x41,0x8C,0x6D,0x4D,0xFF,0x08,0xC9,0x7C,0xD2,0xBE,0xD4,0xCB,0x7F,0x88,0xD8,0xC8,0xE5,0x89};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^73)*G
			{
				const static sl_uint8 _x[] = {0x26,0x95,0x2C,0x7F,0x37,0x2E,0x59,0x36,0x0D,0x5C,0xE4,0xC6,0x62,0x91,0xF0,0xB6,0xEF,0x16,0xC1,0x33,0x1E,0x82,0x5E,0x51,0x39,0x6E,0xB0,0x45,0x7E,0x8B,0x00,0x0A};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xF5,0x13,0xEA,0x4C,0x58,0x00,0xA6,0x88,0x62,0xBC,0x89,0x3D,0x2D,0x68,0x84,0x22,0xDE,0xBE,0x39,0x8F,0x65,0x3D,0x67,0x31,0x8C,0x3D,0x40,0x1F,0x05,0xEF,0x70,0x5A};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^74)*G
			{
				const static sl_uint8 _x[] = {0xC6,0x2E,0x58,0xE6,0xFC,0x23,0xC5,0xBD,0xBE,0xF2,0xBE,0x8B,0x13,0x1F,0xF2,0x43,0xF5,0x21,0x19,0x65,0x72,0xD6,0xB0,0xE9,0xF1,0x02,0x58,0x89,0x76,0x13,0x4F,0x96};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x43,0x97,0x82,0x7D,0x45,0xB1,0xA1,0x67,0x8C,0x3D,0x67,0x67,0x53,0x14,0x1F,0xC5,0xBC,0xFB,0x85,0x35,0x63,0x73,0x1C,0x3E,0x82,0x27,0x7E,0xD4,0xD1,0x4C,0xF9,0x7E};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^75)*G
			{
				const static sl_uint8 _x[] = {0x10,0x74,0x60,0x52,0x0E,0xEC,0x5C,0x74,0x16,0x83,0x32,0x9A,0x71,0x66,0x22,0xB0,0xB8,0x1C,0x03,0x20,0x08,0x07,0xDE,0x97,0x36,0x86,0xF8,0x80,0x0B,0x18,0x8C,0xBB};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xAB,0xE5,0xD4,0xC0,0x9A,0x21,0x59,0x8C,0x35,0x32,0x6B,0x9B,0x9C,0xF5,0x4A,0x11,0x24,0x2E,0x0D,0x74,0x8D,0xCE,0x3D,0xA6,0x01,0xD7,0xB6,0x36,0x1F,0x27,0x21,0x24};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^76)*G
			{
				const static sl_uint8 _x[] = {0x62,0x60,0xCE,0x7F,0x46,0x18,0x01,0xC3,0x4F,0x06,0x7C,0xE0,0xF0,0x28,0x73,0xA8,0xF1,0xB0,0xE4,0x4D,0xFC,0x69,0x75,0x2A,0xCC,0xEC,0xD8,0x19,0xF3,0x8F,0xD8,0xE8};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xBC,0x2D,0xA8,0x2B,0x6F,0xA5,0xB5,0x71,0xA7,0xF0,0x90,0x49,0x77,0x6A,0x1E,0xF7,0xEC,0xD2,0x92,0x23,0x80,0x51,0xC1,0x98,0xC1,0xA8,0x4E,0x95,0xB2,0xB4,0xAE,0x17};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^77)*G
			{
				const static sl_uint8 _x[] = {0x85,0xD8,0xDA,0x47,0x48,0xAD,0x1A,0x73,0xDE,0xC8,0x40,0x9B,0xE8,0x4F,0x1A,0x13,0x16,0xE6,0x5C,0x51,0x96,0xAA,0xD2,0x7E,0x07,0x66,0x74,0x6F,0x3D,0x47,0x7C,0x2D};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x58,0x94,0x8B,0x53,0x66,0x5C,0x66,0x90,0x58,0x6B,0x53,0x65,0x31,0xEF,0xC7,0xBC,0x94,0xB0,0xA0,0x20,0x33,0xC4,0xD5,0xA6,0x20,0x79,0x81,0x6F,0xC7,0xD1,0xDD,0x70};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^78)*G
			{
				const static sl_uint8 _x[] = {0x8E,0x2A,0x71,0x66,0xE7,0xEC,0x4B,0x96,0x8C,0x08,0x92,0xE9,0xCC,0x3E,0xE3,0xEE,0x4D,0x1E,0x7E,0x10,0x0F,0xDC,0x47,0xF0,0x48,0x50,0x31,0x2D,0x6C,0x0B,0x80,0xD9};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xEA,0xDB,0x0B,0xA9,0xAE,0x2C,0xBE,0x59,0x2C,0xED,0xD2,0x9B,0x71,0x6A,0x9D,0x48,0x52,0x97,0xB6,0x88,0xD7,0x06,0x34,0x9A,0x49,0xC6,0x1F,0x2A,0xD6,0xB2,0x9F,0x50};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^79)*G
			{
				const static sl_uint8 _x[] = {0x76,0x9B,0xC7,0x58,0x42,0xBF,0xF5,0x8E,0xDC,0x83,0x66,0xEC,0xD7,0x8F,0x89,0x50,0xEE,0x4A,0xB2,0xE8,0x13,0x59,0xD9,0x0F,0x99,0x21,0xFA,0x3D,0x2C,0x45,0x61,0xBE};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x4B,0xF8,0x17,0x36,0x2F,0xE7,0x83,0xBA,0xC8,0xDC,0xE4,0xCE,0xF7,0x3F,0x5D,0x47,0x41,0xA1,0x77,0x76,0x7B,0x78,0x73,0xAD,0xD5,0x92,0x0B,0xFF,0xB0,0xD9,0x68,0x5F};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^80)*G
			{
				const static sl_uint8 _x[] = {0xE5,0x03,0x7D,0xE0,0xAF,0xC1,0xD8,0xD4,0x3D,0x83,0x48,0x41,0x4B,0xBF,0x41,0x03,0x04,0x3E,0xC8,0xF5,0x75,0xBF,0xDC,0x43,0x29,0x53,0xCC,0x8D,0x20,0x37,0xFA,0x2D};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x45,0x71,0x53,0x4B,0xAA,0x94,0xD3,0xB5,0xF9,0xF9,0x8D,0x09,0xFB,0x99,0x0B,0xDD,0xBD,0x5F,0x5B,0x03,0xEC,0x48,0x1F,0x10,0xE0,0xE5,0xDC,0x84,0x1D,0x75,0x5B,0xDA};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^81)*G
			{
				const static sl_uint8 _x[] = {0xA5,0xE0,0x0D,0xA4,0x67,0xFD,0x54,0x94,0xF4,0x0B,0x6C,0xF7,0xD2,0xD6,0x1B,0x3E,0xC3,0xAB,0x21,0x7C,0x79,0x2A,0x2D,0xDB,0x8C,0x63,0xC8,0xC7,0x9E,0x3D,0x34,0xEF};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x09,0x8F,0xE5,0xF5,0xE5,0x60,0x85,0x55,0x42,0x17,0x26,0xFE,0x99,0xBF,0x43,0xD2,0x5B,0x60,0xDC,0xFE,0x79,0x09,0x00,0xAC,0xB8,0x55,0xC5,0xCE,0x2F,0x7A,0xDB,0x4C};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^82)*G
			{
				const static sl_uint8 _x[] = {0xA9,0x94,0x15,0xF5,0xEF,0x3A,0x2B,0x40,0x35,0x19,0xF4,0xBB,0x1C,0x9B,0xFB,0xC4,0x6D,0x4A,0xFD,0x2E,0x44,0x77,0x57,0x2A,0xE6,0x73,0x71,0x60,0xD7,0xB9,0x12,0x52};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x82,0xD0,0xE6,0x4C,0xAE,0x81,0xF8,0x4B,0xB9,0xE2,0xF1,0x0F,0x24,0xF6,0xF6,0xB6,0x89,0x9A,0x16,0xAD,0x59,0x0F,0x4D,0xDD,0x73,0xA3,0x77,0xAC,0x4B,0xED,0xC2,0x64};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^83)*G
			{
				const static sl_uint8 _x[] = {0xB5,0x6F,0x4E,0x9F,0x9E,0x4F,0xD1,0xFC,0x7D,0x8E,0xDD,0xE0,0x98,0xF9,0x35,0xF8,0x4C,0x75,0x0D,0x70,0x5F,0x0C,0x13,0x2B,0xD8,0xC4,0x65,0xB6,0x6A,0x54,0x0F,0x17};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x32,0xE8,0xE5,0x34,0x29,0xCC,0xA8,0x56,0xD3,0xDC,0x11,0xAD,0xF0,0x58,0x2D,0x1D,0x21,0xD4,0x29,0x63,0xCB,0xCC,0xA8,0x54,0x46,0xA2,0xFC,0xAE,0x02,0x00,0x10,0x2D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^84)*G
			{
				const static sl_uint8 _x[] = {0xE0,0x63,0x72,0xB0,0xF4,0xA2,0x07,0xAD,0xF5,0xEA,0x90,0x5E,0x8F,0x17,0x71,0xB4,0xE7,0xE8,0xDB,0xD1,0xC6,0xA6,0xC5,0xB7,0x25,0x86,0x6A,0x0A,0xE4,0xFC,0xE7,0x25};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x7A,0x90,0x89,0x74,0xBC,0xE1,0x8C,0xFE,0x12,0xA2,0x7B,0xB2,0xAD,0x5A,0x48,0x8C,0xD7,0x48,0x4A,0x77,0x87,0x10,0x48,0x70,0xB2,0x70,0x34,0xF9,0x4E,0xEE,0x31,0xDD};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^85)*G
			{
				const static sl_uint8 _x[] = {0x0E,0xAC,0x13,0x4C,0xA2,0x04,0x6B,0x8F,0x9C,0x8D,0xBD,0x30,0x4F,0xAD,0x3F,0x3C,0x04,0x5E,0xBF,0xDB,0x4E,0xC6,0xED,0x3C,0xFE,0x09,0xAE,0xE4,0x3E,0xD2,0xFF,0x3E};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x49,0x63,0x0D,0xBE,0x79,0x35,0x9B,0x42,0x45,0xBF,0x10,0x3B,0xF2,0xB1,0x17,0x99,0xAC,0x19,0xF6,0x96,0xB7,0xF2,0x13,0x76,0xE1,0x72,0x06,0x20,0x7D,0x21,0x09,0x88};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^86)*G
			{
				const static sl_uint8 _x[] = {0xD6,0x78,0x85,0x90,0x73,0x1F,0xEA,0x19,0x83,0x92,0x11,0x9D,0x7A,0xDB,0xB4,0x1F,0xF5,0x94,0x8A,0x78,0x04,0xC8,0x5B,0x17,0x47,0x67,0x06,0xE4,0xDF,0xBF,0xA4,0xDC};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x28,0xEA,0xA8,0xC8,0x9D,0x50,0x63,0xC4,0x94,0x0E,0xF5,0xC6,0xD2,0x1C,0x13,0xAA,0x62,0x06,0xF1,0xC4,0xDD,0xC9,0xA0,0x7C,0xCA,0x7B,0xCD,0x6B,0xBD,0x3B,0x54,0x06};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^87)*G
			{
				const static sl_uint8 _x[] = {0x69,0x30,0xFC,0xCB,0xD9,0xA0,0x40,0x97,0x4A,0xBF,0x21,0x0F,0x12,0xB7,0x1D,0x4B,0xC7,0xB1,0xA6,0x20,0x55,0x99,0xB0,0x1A,0x72,0x75,0xFB,0x40,0xE4,0x8F,0xF9,0xB3};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x7F,0x02,0xAE,0x94,0xB9,0x47,0x01,0xEA,0xDA,0x30,0xFC,0xDB,0x87,0x5F,0x6D,0x78,0x09,0x0F,0x9B,0x13,0xE4,0xAC,0xC5,0x1A,0xCF,0xDD,0xAB,0x5F,0x8E,0xE9,0x6A,0x4E};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^88)*G
			{
				const static sl_uint8 _x[] = {0x21,0x3C,0x7A,0x71,0x5C,0xD5,0xD4,0x53,0x58,0xD0,0xBB,0xF9,0xDC,0x0C,0xE0,0x22,0x04,0xB1,0x0B,0xDD,0xE2,0xA3,0xF5,0x85,0x40,0xAD,0x69,0x08,0xD0,0x55,0x97,0x54};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x4B,0x6D,0xAD,0x0B,0x5A,0xE4,0x62,0x50,0x70,0x13,0xAD,0x06,0x24,0x5B,0xA1,0x90,0xBB,0x48,0x50,0xF5,0xF3,0x6A,0x7E,0xED,0xDF,0xF2,0xC2,0x75,0x34,0xB4,0x58,0xF2};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^89)*G
			{
				const static sl_uint8 _x[] = {0x1C,0x5E,0x54,0x81,0x32,0xB4,0x9A,0x7F,0x66,0xAE,0x9F,0xED,0x83,0x23,0x48,0x0E,0x0D,0x1A,0xB9,0x74,0x62,0x2E,0x7C,0xF0,0x89,0x93,0x89,0x5E,0x0E,0xC8,0x7F,0xAC};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x4F,0xFC,0xF6,0x0F,0x83,0x7F,0x46,0x8F,0x2B,0xB9,0x59,0xFA,0x1D,0x4C,0x2A,0xD3,0xA3,0xDE,0xAC,0xEB,0x26,0xFE,0x32,0x4C,0x55,0x5D,0x7B,0x3D,0x5F,0xC2,0xD4,0xEF};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^90)*G
			{
				const static sl_uint8 _x[] = {0x46,0x27,0x6D,0x06,0x02,0xC5,0x66,0x8D,0xDE,0xF6,0xE9,0x42,0x10,0xBB,0xC7,0xCE,0x1F,0x90,0x1C,0x19,0xFE,0xD5,0xC9,0x70,0xE2,0x0F,0xCB,0xA1,0xD4,0x53,0x1D,0xBC};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x0E,0x0F,0x7F,0x24,0xD4,0x4C,0x75,0xB8,0x4A,0x29,0x22,0x87,0x57,0x0D,0xED,0x99,0x49,0x8B,0xAD,0xFB,0xFF,0xE1,0xBC,0x99,0xAF,0x87,0x30,0x09,0x96,0x86,0xB8,0xE2};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^91)*G
			{
				const static sl_uint8 _x[] = {0xEF,0xEA,0x68,0xEC,0xA7,0xA6,0xC2,0x4F,0x4E,0x65,0xEB,0x21,0x1C,0x31,0x91,0x63,0x68,0x50,0xE0,0xAC,0xDC,0x78,0xD8,0x99,0x61,0x14,0xEF,0x13,0x52,0x2F,0x00,0x1D};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xAA,0xB8,0x47,0x86,0x9D,0x58,0x3C,0x14,0xDA,0x15,0x03,0x07,0xA3,0x71,0x9A,0x17,0xE4,0x13,0x95,0x9F,0xB3,0x84,0x87,0x71,0xC1,0x28,0x41,0x9F,0x73,0xBC,0x44,0x15};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^92)*G
			{
				const static sl_uint8 _x[] = {0x4E,0x7C,0x27,0x2A,0x7A,0xF4,0xB3,0x4E,0x8D,0xBB,0x93,0x52,0xA5,0x41,0x9A,0x87,0xE2,0x83,0x8C,0x70,0xAD,0xC6,0x2C,0xDD,0xF0,0xCC,0x3A,0x3B,0x08,0xFB,0xD5,0x3C};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x17,0x74,0x9C,0x76,0x6C,0x9D,0x0B,0x18,0xE1,0x6F,0xD0,0x9F,0x6D,0xEF,0x68,0x1B,0x53,0x0B,0x96,0x14,0xBF,0xF7,0xDD,0x33,0xE0,0xB3,0x94,0x18,0x17,0xDC,0xAA,0xE6};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^93)*G
			{
				const static sl_uint8 _x[] = {0x89,0x90,0x17,0xB0,0x26,0x96,0x88,0x8F,0x26,0x8A,0x26,0x9F,0x4E,0x38,0x5D,0x9C,0x9B,0x11,0xF2,0x5A,0x1B,0xEF,0x87,0x90,0xE2,0x82,0x1E,0x6E,0x7C,0x6E,0x1B,0x4D};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x43,0xAE,0x2C,0xDA,0xB5,0xB3,0x34,0xF0,0xBB,0x45,0x79,0x83,0x36,0x35,0x8B,0xFA,0xE4,0xE5,0x1B,0xC0,0xF9,0x32,0xB2,0x12,0x00,0x9A,0xEB,0xDA,0xD8,0x14,0xAB,0x2B};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^94)*G
			{
				const static sl_uint8 _x[] = {0x67,0xF6,0x44,0xF7,0x6E,0x90,0x5F,0xD4,0xA8,0xF4,0x72,0x8E,0x63,0x22,0x7F,0x0E,0x28,0x31,0xF5,0xBF,0x91,0xB5,0x83,0xA8,0xAF,0x26,0x35,0xA1,0x7E,0x5F,0x71,0x2F};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xB8,0x33,0xD6,0x8F,0x66,0x44,0x5D,0x04,0xF0,0x5A,0xDE,0xB7,0xB5,0x86,0xCF,0x78,0x5E,0x0E,0x14,0x88,0xF7,0xD3,0x61,0x98,0xD6,0x8A,0xCB,0x5E,0x70,0x71,0x60,0xE5};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^95)*G
			{
				const static sl_uint8 _x[] = {0x32,0x7F,0x87,0x6C,0x93,0x65,0x25,0x55,0xFA,0x80,0xA0,0x54,0x96,0x8B,0x47,0x12,0x93,0x0D,0xC9,0x30,0x12,0xEE,0x6B,0x8D,0xC1,0x02,0x63,0xED,0x3B,0x89,0xA7,0x62};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xB2,0xD4,0x04,0xEA,0xB3,0x52,0x40,0x26,0xB0,0x99,0x69,0x25,0x5E,0x19,0x97,0xB9,0x75,0x53,0x50,0x70,0xFE,0xBD,0x7D,0xFE,0x9C,0x9F,0xD9,0x59,0xB9,0x20,0x33,0x01};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^96)*G
			{
				const static sl_uint8 _x[] = {0xFE,0xA7,0x4E,0x3D,0xBE,0x77,0x8B,0x1B,0x10,0xF2,0x38,0xAD,0x61,0x68,0x6A,0xA5,0xC7,0x6E,0x3D,0xB2,0xBE,0x43,0x05,0x76,0x32,0x42,0x7E,0x28,0x40,0xFB,0x27,0xB6};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x6E,0x05,0x68,0xDB,0x9B,0x0B,0x13,0x29,0x7C,0xF6,0x74,0xDE,0xCC,0xB6,0xAF,0x93,0x12,0x6B,0x59,0x6B,0x97,0x3F,0x7B,0x77,0x70,0x1D,0x3D,0xB7,0xF2,0x3C,0xB9,0x6F};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^97)*G
			{
				const static sl_uint8 _x[] = {0xED,0x94,0x41,0xC8,0x30,0x42,0x80,0xFF,0x18,0x0E,0x03,0xD8,0x50,0xE8,0xCD,0x0E,0xBB,0x57,0x0E,0xE5,0xDE,0x37,0x30,0x48,0x8F,0xD9,0x7C,0x96,0x1F,0x97,0x56,0xE4};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x3D,0xBE,0x9E,0x9E,0xFE,0x8B,0xFA,0x19,0xAF,0xA1,0x76,0x12,0x8B,0x13,0x91,0x1E,0x09,0xF2,0x37,0x74,0xFE,0x4D,0xE9,0x8B,0xFF,0x0E,0x09,0xF9,0x3F,0x3A,0xBF,0xAE};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^98)*G
			{
				const static sl_uint8 _x[] = {0x29,0xD9,0x69,0x8E,0xE6,0x7A,0x7C,0x3F,0xC9,0xFE,0xD3,0xF6,0x24,0xB4,0x87,0x51,0x5B,0x10,0xBD,0xD8,0x4F,0xAB,0x4D,0x30,0x15,0xBA,0xD0,0x33,0xD5,0x1C,0xF1,0x19};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x7F,0xD0,0x2C,0x51,0x7D,0xC8,0x2B,0x45,0x27,0x7A,0x12,0x54,0x04,0xF1,0xC9,0x6F,0xB8,0x9C,0x94,0x0E,0x93,0xA7,0xC2,0x96,0x3C,0x88,0x74,0x05,0x75,0x05,0x63,0x39};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^99)*G
			{
				const static sl_uint8 _x[] = {0x12,0x6B,0x57,0xD0,0x50,0x13,0x93,0x6D,0x6F,0x3F,0xB7,0xBD,0x33,0x58,0x0A,0x31,0xFD,0x45,0x3E,0x4A,0x86,0x06,0x0C,0xFF,0x46,0x7C,0x44,0x53,0x7F,0x42,0x24,0x91};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xC1,0xA7,0xDC,0x13,0x06,0x16,0x62,0xC2,0xE3,0xC4,0xA3,0xEB,0xA2,0xBF,0x3F,0xB0,0xE1,0x48,0xBA,0xC3,0x0B,0xF3,0x93,0x47,0xAF,0xA3,0x1F,0x19,0x9D,0xA3,0xEF,0x84};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^100)*G
			{
				const static sl_uint8 _x[] = {0x76,0xE6,0x41,0x13,0xF6,0x77,0xCF,0x0E,0x10,0xA2,0x57,0x0D,0x59,0x99,0x68,0xD3,0x15,0x44,0xE1,0x79,0xB7,0x60,0x43,0x29,0x52,0xC0,0x2A,0x44,0x17,0xBD,0xDE,0x39};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xC9,0x0D,0xDF,0x8D,0xEE,0x4E,0x95,0xCF,0x57,0x70,0x66,0xD7,0x06,0x81,0xF0,0xD3,0x5E,0x2A,0x33,0xD2,0xB5,0x6D,0x20,0x32,0xB4,0xB1,0x75,0x2D,0x19,0x01,0xAC,0x01};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^101)*G
			{
				const static sl_uint8 _x[] = {0x70,0x8A,0x53,0x0E,0x9E,0x52,0xC7,0x3B,0xEE,0x87,0xC9,0xD8,0x81,0x61,0xC8,0x10,0x00,0x5D,0x57,0x62,0x2C,0x29,0xAE,0x69,0x1C,0xF9,0x99,0xA8,0x3A,0x11,0x87,0xA5};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x9B,0x88,0x48,0x11,0xE1,0xF9,0xA8,0x97,0xFA,0x96,0x56,0xDC,0xBB,0x6D,0x38,0x28,0x3E,0xCD,0xA7,0x3C,0x6D,0x35,0x3E,0x8A,0x58,0xA4,0xF1,0x9B,0x47,0x3D,0xB9,0xC0};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^102)*G
			{
				const static sl_uint8 _x[] = {0x19,0xCF,0x03,0x4F,0xC4,0x8B,0x3B,0xE2,0x19,0xBD,0x64,0x83,0x95,0xE4,0x62,0xCF,0x9F,0x37,0x4B,0x6D,0x86,0xB2,0xB5,0x9E,0x2E,0x1B,0x16,0xC6,0xCD,0xE4,0xF5,0xBE};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x28,0xE3,0x2B,0x06,0xA1,0x5A,0xB4,0x66,0xC3,0xB4,0xBE,0x68,0xAB,0x18,0x19,0x47,0xEF,0x91,0xD1,0xC9,0x3F,0x0F,0x1C,0x0C,0x0A,0x91,0x53,0x2B,0x6F,0x32,0x1A,0xF2};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^103)*G
			{
				const static sl_uint8 _x[] = {0xAF,0x6C,0x44,0xA0,0x78,0xCB,0x5F,0x0D,0x7C,0x71,0x9C,0x2F,0x83,0x97,0xF5,0x76,0xEE,0x93,0xBD,0x03,0x4B,0xEA,0x22,0x19,0xE3,0xAB,0xC2,0x09,0xD1,0x7C,0xF3,0xE8};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x07,0x84,0x09,0x6F,0xE8,0x5D,0x4B,0x30,0xAF,0x9E,0x73,0x15,0x3C,0xB2,0x46,0xDF,0xEC,0x36,0x2A,0xEA,0x7C,0xA0,0xD4,0x35,0xB8,0xAD,0xD0,0x60,0x17,0x51,0xBA,0xEA};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^104)*G
			{
				const static sl_uint8 _x[] = {0xC7,0x38,0xC5,0x6B,0x03,0xB2,0xAB,0xE1,0xE8,0x28,0x1B,0xAA,0x74,0x3F,0x8F,0x9A,0x8F,0x7C,0xC6,0x43,0xDF,0x26,0xCB,0xEE,0x3A,0xB1,0x50,0x24,0x2B,0xCB,0xB8,0x91};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x89,0x3F,0xB5,0x78,0x95,0x1A,0xD2,0x53,0x7F,0x71,0x8F,0x2E,0xAC,0xBF,0xBB,0xBB,0x82,0x31,0x4E,0xEF,0x78,0x80,0xCF,0xE9,0x17,0xE7,0x35,0xD9,0x69,0x9A,0x84,0xC3};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^105)*G
			{
				const static sl_uint8 _x[] = {0x55,0x78,0x84,0x5E,0xCD,0x7C,0x03,0x74,0x35,0xB3,0x2A,0x69,0x92,0xE7,0xAA,0x94,0x64,0x71,0x97,0xEA,0x49,0xB8,0xC9,0xE4,0xDD,0xAA,0xB0,0x78,0x46,0x62,0xAB,0x1B};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xE6,0x1D,0x07,0x97,0x8B,0x6D,0xE2,0xC3,0xCE,0xA6,0xD0,0xA5,0x1D,0x2A,0x40,0x53,0xF6,0x53,0xA7,0x74,0x6A,0x5D,0x64,0xDE,0x31,0x6D,0x18,0xF3,0x05,0x6F,0x35,0x11};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^106)*G
			{
				const static sl_uint8 _x[] = {0x47,0xF3,0x38,0x38,0x88,0xA3,0x64,0xCC,0x4A,0xBF,0xA3,0xBC,0x1D,0x0C,0xEC,0xCD,0x22,0xF1,0x23,0x54,0xFC,0xE3,0x99,0x60,0x94,0xF8,0x69,0xB8,0x94,0x8B,0x6C,0x29};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x48,0xCA,0x9A,0x8D,0x0F,0x03,0x29,0x37,0x19,0x0E,0x48,0x67,0x5B,0x41,0x6C,0x71,0x18,0xBB,0x49,0x95,0x88,0xF9,0x94,0xA8,0x1E,0xDE,0xE1,0x12,0x0E,0x53,0x7E,0xF9};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^107)*G
			{
				const static sl_uint8 _x[] = {0xC0,0xC0,0x1F,0x34,0xAE,0x41,0xB8,0xCF,0xE4,0x66,0xB4,0xC9,0xC6,0xA5,0xD5,0xF6,0x14,0xF5,0x70,0xD6,0xFC,0xBE,0xF7,0x68,0xA8,0x1A,0x6C,0x8F,0x05,0xFF,0x4A,0xDB};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x0B,0x84,0xF5,0xBE,0xE4,0x35,0x7F,0x5C,0x7C,0x93,0x7A,0x0B,0x40,0x75,0xB8,0xCE,0xCD,0xBC,0x43,0xD1,0x70,0xD1,0x5B,0x85,0xFC,0x4E,0xFF,0x73,0xAC,0x35,0x10,0x65};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^108)*G
			{
				const static sl_uint8 _x[] = {0xD8,0x95,0x62,0x65,0x48,0xB6,0x5B,0x81,0xE2,0x64,0xC7,0x63,0x7C,0x97,0x28,0x77,0xD1,0xD7,0x2E,0x5F,0x3A,0x92,0x50,0x14,0x37,0x2E,0x9F,0x65,0x88,0xF6,0xC1,0x4B};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xFE,0xBF,0xAA,0x38,0xF2,0xBC,0x7E,0xAE,0x72,0x8E,0xC6,0x08,0x18,0xC3,0x40,0xEB,0x03,0x42,0x8D,0x63,0x2B,0xB0,0x67,0xE1,0x79,0x36,0x3E,0xD7,0x5D,0x7D,0x99,0x1F};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^109)*G
			{
				const static sl_uint8 _x[] = {0xFD,0x13,0x6E,0xEF,0x89,0x71,0x04,0x4E,0x8A,0x3A,0x43,0x62,0x20,0x03,0xA2,0x67,0x03,0xEC,0xAF,0x7A,0x0E,0xC4,0x0C,0x3F,0xBA,0x5B,0x59,0x4B,0x77,0x07,0x84,0x24};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x21,0x8D,0xA8,0x34,0xF3,0xC6,0x52,0xCC,0x67,0xA1,0xD1,0x91,0xB5,0xC5,0xEF,0xA5,0x7C,0xF2,0xB1,0xF7,0x8A,0x2A,0xDF,0xA8,0xCD,0x61,0xEE,0xEF,0xC6,0x71,0xDD,0xF1};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^110)*G
			{
				const static sl_uint8 _x[] = {0xD9,0x9E,0x8E,0x9D,0xD9,0x63,0x8D,0x14,0x0E,0x9C,0xCA,0x53,0x67,0x51,0x9F,0x86,0x1B,0x70,0x03,0xA0,0xD4,0x3F,0x02,0x4A,0x5F,0x1D,0x84,0xEC,0x8D,0xB1,0xCB,0x3C};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x36,0xDC,0x19,0xAD,0x1C,0xC0,0xA3,0xA7,0xA9,0x45,0xBB,0x32,0x1B,0xCE,0xBA,0x6E,0x62,0x86,0xFE,0xF8,0xFF,0xC8,0x76,0x5C,0xD8,0x8A,0x29,0xE3,0x6B,0x86,0x37,0xA7};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^111)*G
			{
				const static sl_uint8 _x[] = {0x03,0xFD,0xF1,0x61,0x9A,0x19,0x83,0x17,0xA1,0xBD,0x8A,0x54,0xE5,0xB0,0x91,0x91,0xD2,0x03,0x35,0x1E,0x04,0x40,0xE6,0x36,0xFD,0x46,0xF6,0x8D,0x3C,0x38,0x51,0x72};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x40,0x8D,0x02,0xC0,0x6E,0x5C,0x12,0xC3,0xFE,0x47,0x0C,0x7D,0x3C,0x85,0x73,0x75,0x5B,0x9B,0x92,0x9E,0x90,0xE7,0x23,0x2B,0x79,0xAC,0x67,0xF0,0xFC,0xCB,0x97,0x94};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^112)*G
			{
				const static sl_uint8 _x[] = {0xB8,0xDA,0x94,0x03,0x2A,0x95,0x75,0x18,0xEB,0x0F,0x64,0x33,0x57,0x1E,0x87,0x61,0xCE,0xFF,0xC7,0x36,0x93,0xE8,0x4E,0xDD,0x49,0x15,0x0A,0x56,0x4F,0x67,0x6E,0x03};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x28,0x04,0xDF,0xA4,0x48,0x05,0xA1,0xE4,0xD7,0xC9,0x9C,0xC9,0x76,0x28,0x08,0xB0,0x92,0xCC,0x58,0x4D,0x95,0xFF,0x3B,0x51,0x14,0x88,0xE4,0xE7,0x4E,0xFD,0xF6,0xE7};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^113)*G
			{
				const static sl_uint8 _x[] = {0x6D,0x36,0xD1,0x05,0xED,0x8C,0xC5,0xCE,0x53,0xF2,0xCB,0x69,0x8A,0xB6,0x20,0xF9,0x46,0x9A,0x3E,0x5C,0xB2,0x5B,0xF6,0xE6,0xD4,0x13,0xF4,0x14,0xC5,0xAF,0x72,0x6A};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xE4,0xBA,0x5C,0x34,0xE3,0x77,0x66,0x9E,0x72,0xD8,0xC6,0x6C,0x95,0xC5,0x00,0x29,0xDC,0xC5,0x99,0x36,0xB4,0x10,0x8A,0x35,0xC5,0x70,0x49,0x1A,0x13,0xF9,0xFC,0x7D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^114)*G
			{
				const static sl_uint8 _x[] = {0x3A,0xB6,0xBD,0xE1,0x0C,0xD3,0xAC,0x0C,0xD0,0x68,0x83,0xFA,0x66,0xF0,0xB0,0xE3,0xEB,0x13,0x09,0xC0,0x53,0x4B,0x81,0x22,0x86,0xE2,0xA3,0x0C,0xA5,0x40,0xDB,0x99};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xBA,0xCA,0x62,0x07,0x9B,0xE8,0x71,0xD7,0xFC,0x31,0x17,0xA9,0x6A,0x13,0xE9,0x9C,0x38,0xD1,0x37,0xB0,0xE3,0x69,0xC0,0x43,0xE6,0x87,0x3F,0xE3,0x1B,0xDA,0x78,0xA3};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^115)*G
			{
				const static sl_uint8 _x[] = {0x79,0x66,0x34,0xE3,0xF1,0xAD,0x56,0xF0,0xFD,0xBA,0x06,0x9D,0x9D,0x07,0xBC,0xE2,0xBA,0x2F,0xD4,0xF3,0x73,0xDD,0xD3,0xBA,0x77,0x77,0xBF,0x27,0x9F,0x10,0x48,0xDA};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x4D,0x8E,0xE2,0xB6,0xCF,0xB2,0x0B,0x89,0x56,0xDE,0x74,0x73,0x5A,0x79,0x27,0xF2,0x53,0x25,0x76,0xD8,0xCF,0xD7,0x48,0x62,0xE8,0xF9,0xBE,0x24,0xA1,0x06,0xCF,0x01};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^116)*G
			{
				const static sl_uint8 _x[] = {0xE8,0x0F,0xEA,0x14,0x44,0x1F,0xB3,0x3A,0x7D,0x8A,0xDA,0xB9,0x47,0x5D,0x7F,0xAB,0x20,0x19,0xEF,0xFB,0x51,0x56,0xA7,0x92,0xF1,0xA1,0x17,0x78,0xE3,0xC0,0xDF,0x5D};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xEE,0xD1,0xDE,0x7F,0x63,0x8E,0x00,0x77,0x1E,0x89,0x76,0x8C,0xA3,0xCA,0x94,0x47,0x2D,0x15,0x5E,0x80,0xAF,0x32,0x2E,0xA9,0xFC,0xB4,0x29,0x1B,0x6A,0xC9,0xEC,0x78};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^117)*G
			{
				const static sl_uint8 _x[] = {0x44,0x0C,0xA1,0xF0,0x8E,0xA4,0x12,0x65,0x98,0x1A,0xC4,0xED,0x1E,0xFE,0x7A,0x37,0x12,0x2D,0xCC,0x38,0x77,0xD2,0xF9,0x16,0x2D,0xB0,0xE7,0x8B,0x0F,0x83,0xCD,0x58};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xA6,0xC8,0xB0,0xD2,0xCD,0x5E,0xE1,0x22,0xAF,0x89,0x54,0xDC,0x9D,0x4E,0x2F,0x02,0xA2,0x1E,0x4D,0x42,0x69,0xC0,0xA2,0x60,0xB0,0x7B,0xC0,0x69,0xB8,0x8A,0x3F,0x4B};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^118)*G
			{
				const static sl_uint8 _x[] = {0xF6,0x94,0xCB,0xAF,0x2B,0x96,0x6C,0x1C,0xC5,0xF7,0xF8,0x29,0xD3,0xA9,0x07,0x81,0x9B,0xC7,0x0E,0xBC,0xC1,0xB2,0x29,0xD9,0xE8,0x1B,0xDA,0x27,0x12,0x99,0x8B,0x10};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x40,0xA6,0x3E,0xBA,0x61,0xBE,0xF0,0x3D,0x63,0x3C,0x5F,0xFA,0xCC,0x46,0xD8,0x2A,0xEB,0x6C,0x64,0xC3,0x18,0x3C,0x2A,0x47,0xF6,0x78,0x8B,0x17,0x00,0xF0,0x5E,0x51};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^119)*G
			{
				const static sl_uint8 _x[] = {0x8B,0x6E,0x86,0x2A,0x35,0x56,0x68,0x48,0x50,0xB6,0xD4,0xF4,0x39,0xA2,0x59,0x50,0x47,0xAB,0xF6,0x95,0xC0,0x8B,0x64,0x14,0xF9,0x5A,0x13,0x35,0x8D,0xD5,0x53,0xFD};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xEA,0x5E,0x08,0x91,0x0E,0xD1,0x1C,0xB4,0x0D,0x10,0xBC,0x2D,0xF4,0xEB,0x9F,0xA1,0x24,0xAC,0x3C,0x5A,0x18,0x33,0x83,0xD0,0xD8,0x03,0xDA,0xD3,0x3E,0x9B,0xE5,0xED};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^120)*G
			{
				const static sl_uint8 _x[] = {0xA3,0x01,0x69,0x7B,0xDF,0xCD,0x70,0x43,0x13,0xBA,0x48,0xE5,0x1D,0x56,0x75,0x43,0xF2,0xA1,0x82,0x03,0x1E,0xFD,0x69,0x15,0xDD,0xC0,0x7B,0xBC,0xC4,0xE1,0x60,0x70};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x73,0x70,0xF9,0x1C,0xFB,0x67,0xE4,0xF5,0x08,0x18,0x09,0xFA,0x25,0xD4,0x0F,0x9B,0x17,0x35,0xDB,0xF7,0xC0,0xA1,0x1A,0x13,0x0C,0x0D,0x1A,0x04,0x1E,0x17,0x7E,0xA1};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^121)*G
			{
				const static sl_uint8 _x[] = {0x27,0xE1,0xE5,0x9C,0xFF,0x79,0xF0,0x49,0xF3,0xE8,0xD2,0x41,0x9E,0x0B,0xFF,0x74,0xB4,0x39,0x65,0x00,0x4C,0x34,0xB5,0xD8,0x11,0x42,0x03,0x16,0xF2,0x4B,0xA5,0xAE};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x31,0x0B,0x26,0xA6,0xC8,0x04,0xE2,0x09,0xEE,0x1B,0x5E,0x3C,0xFC,0x79,0xDF,0x05,0xDF,0x48,0xA1,0xA6,0x9A,0xFA,0x63,0xF7,0x84,0xA5,0xBF,0xEE,0x88,0x3A,0x45,0xB3};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^122)*G
			{
				const static sl_uint8 _x[] = {0xC7,0x12,0xE7,0xA5,0xF6,0x86,0x4A,0xEE,0x16,0x58,0x8E,0xC3,0x89,0x2D,0x7E,0x4F,0x5A,0x39,0xAD,0xDE,0x84,0xFB,0xFB,0x4F,0x99,0x69,0x17,0x5C,0x9C,0xAE,0xD7,0xAE};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x49,0x64,0x41,0x07,0x51,0x63,0x63,0xB3,0x65,0xED,0x4B,0x82,0x31,0x1D,0xD9,0xE5,0x38,0x0D,0x8E,0x54,0x4B,0x0C,0xE6,0x37,0x84,0xD1,0x48,0xAA,0x46,0x15,0x62,0x94};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^123)*G
			{
				const static sl_uint8 _x[] = {0x0B,0xFC,0x05,0x04,0xA4,0xB3,0x23,0x5D,0x06,0x5C,0x0D,0x42,0x6B,0x86,0x75,0xFC,0xB2,0xC8,0x5D,0x6F,0x58,0x27,0x5D,0x79,0x1B,0x43,0xE1,0xFE,0x44,0xA6,0xDB,0x03};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x19,0x55,0x46,0x7A,0x6C,0x34,0xF3,0x45,0x3F,0xB8,0xEC,0x7F,0x94,0xA6,0xC9,0x92,0x37,0x42,0x71,0x97,0x34,0x5D,0x4F,0x05,0x58,0xAC,0x8D,0x1A,0x46,0x4B,0x85,0x42};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^124)*G
			{
				const static sl_uint8 _x[] = {0x90,0xAD,0x85,0xB3,0x89,0xD6,0xB9,0x36,0x46,0x3F,0x9D,0x05,0x12,0x67,0x8D,0xE2,0x08,0xCC,0x33,0x0B,0x11,0x30,0x7F,0xFF,0xAB,0x7A,0xC6,0x3E,0x3F,0xB0,0x4E,0xD4};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x0E,0x50,0x7A,0x36,0x20,0xA3,0x82,0x61,0xAF,0xFD,0xCB,0xD9,0x42,0x72,0x22,0xB8,0x39,0xAE,0xFA,0xBE,0x15,0x82,0x89,0x4D,0x99,0x1D,0x4D,0x48,0xCB,0x6E,0xF1,0x50};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^125)*G
			{
				const static sl_uint8 _x[] = {0x7E,0x2C,0xD4,0x0E,0xF8,0xC9,0x40,0x77,0xF4,0x4B,0x1D,0x15,0x48,0x42,0x5E,0x3D,0x7E,0x12,0x5B,0xE6,0x46,0x70,0x7B,0xAD,0x28,0x18,0xB0,0xED,0xA7,0xDC,0x01,0x51};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x90,0x5B,0x75,0x08,0x2A,0xDC,0xFA,0xB3,0x82,0xA6,0x1A,0x8B,0x32,0x1E,0xF9,0x5D,0x88,0x9B,0xEE,0x40,0xAE,0xEE,0x08,0x2C,0x9A,0x3B,0xC5,0x39,0x20,0x72,0x1E,0xC7};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^126)*G
			{
				const static sl_uint8 _x[] = {0xA1,0x46,0xF5,0x21,0x95,0xBE,0xDA,0xCE,0x21,0xC9,0x75,0xBB,0xD1,0xEF,0x52,0xA7,0x9C,0x63,0x6B,0xF9,0xDB,0x85,0x3C,0xF9,0x0E,0x10,0x3A,0xE4,0x13,0x45,0xE5,0x97};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xA5,0xA9,0x9B,0x0A,0xB0,0x53,0xFE,0xB0,0x9A,0xE9,0x5D,0xD2,0xDB,0xB3,0x1B,0x40,0xEA,0x67,0xA5,0xB2,0x21,0xF0,0x94,0xB0,0x76,0x75,0x67,0x6A,0xF4,0x5A,0x77,0x0A};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^127)*G
			{
				const static sl_uint8 _x[] = {0xD2,0x4C,0x75,0xA1,0xCF,0x19,0x93,0xB9,0xBC,0xFB,0xF9,0xDA,0xB2,0x5A,0x81,0x14,0xDB,0xDE,0x42,0x1E,0xFE,0xCC,0xC4,0xE2,0x0C,0xBB,0x53,0xFC,0x4C,0xE4,0x54,0x44};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x58,0xFE,0x1D,0x2D,0xE8,0x4D,0xC1,0xD1,0xCF,0xCB,0x7D,0x18,0x10,0xE5,0xA7,0x8A,0xBF,0x75,0x93,0xF4,0x99,0xF1,0xE5,0x24,0xCB,0x93,0x24,0x69,0x87,0xDD,0x4A,0x57};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^128)*G
			{
				const static sl_uint8 _x[] = {0x8F,0x68,0xB9,0xD2,0xF6,0x3B,0x5F,0x33,0x92,0x39,0xC1,0xAD,0x98,0x1F,0x16,0x2E,0xE8,0x8C,0x56,0x78,0x72,0x3E,0xA3,0x35,0x1B,0x7B,0x44,0x4C,0x9E,0xC4,0xC0,0xDA};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x66,0x2A,0x9F,0x2D,0xBA,0x06,0x39,0x86,0xDE,0x1D,0x90,0xC2,0xB6,0xBE,0x21,0x5D,0xBB,0xEA,0x2C,0xFE,0x95,0x51,0x0B,0xFD,0xF2,0x3C,0xBF,0x79,0x50,0x1F,0xFF,0x82};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^129)*G
			{
				const static sl_uint8 _x[] = {0x4D,0x49,0xAE,0xFD,0x78,0x4E,0x81,0x58,0xFC,0xAF,0xEB,0xE7,0x7F,0xD9,0xAF,0x59,0xD8,0x98,0x58,0xAD,0xE7,0x62,0x7E,0xAE,0xE6,0x84,0x7D,0xF8,0x4C,0xF2,0x70,0x76};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xCD,0x32,0xFC,0x59,0xA1,0x0D,0xD1,0x35,0xE7,0x23,0xF2,0x10,0x35,0x9C,0xA6,0xF0,0x6E,0x0F,0x2D,0x1A,0x7D,0xF4,0xD8,0x46,0x6B,0x90,0xB6,0x62,0x03,0xAA,0x78,0x1E};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^130)*G
			{
				const static sl_uint8 _x[] = {0x75,0x64,0x53,0x9E,0x85,0xD5,0x6F,0x85,0x37,0xD6,0x61,0x9E,0x1F,0x5C,0x5A,0xA7,0x8D,0x2A,0x3D,0xE0,0x88,0x9D,0x1D,0x4E,0xE8,0xDB,0xCB,0x57,0x29,0xB6,0x20,0x26};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xC1,0xD6,0x85,0x41,0x37,0x49,0xB3,0xC6,0x52,0x31,0xDF,0x52,0x4A,0x72,0x29,0x25,0x68,0x4A,0xAC,0xD9,0x54,0xB7,0x9F,0x33,0x41,0x72,0xC8,0xFA,0xDA,0xCE,0x0C,0xF3};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^131)*G
			{
				const static sl_uint8 _x[] = {0x21,0x0A,0x91,0x7A,0xD9,0xDF,0x27,0x79,0x67,0x46,0xFF,0x30,0x1A,0xD9,0xCC,0xC8,0x78,0xF6,0x1A,0x5F,0x1F,0xF4,0x08,0x2B,0x53,0x64,0xDA,0xCD,0x57,0xB4,0xA2,0x78};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x67,0x0E,0x1B,0x54,0x50,0xB5,0xE5,0x7B,0x7A,0x39,0xBE,0x81,0xF8,0xD6,0x73,0x7D,0x37,0x89,0xE6,0x1A,0xAF,0xF2,0x0B,0xFC,0x7F,0x27,0x13,0xFD,0x0C,0x7B,0x22,0x31};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^132)*G
			{
				const static sl_uint8 _x[] = {0xE4,0xF3,0xFB,0x01,0x76,0xAF,0x85,0xD6,0x5F,0xF9,0x9F,0xF9,0x19,0x8C,0x36,0x09,0x1F,0x48,0xE8,0x65,0x03,0x68,0x1E,0x3E,0x66,0x86,0xFD,0x50,0x53,0x23,0x1E,0x11};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x1E,0x63,0x63,0x3A,0xD0,0xEF,0x4F,0x1C,0x16,0x61,0xA6,0xD0,0xEA,0x02,0xB7,0x28,0x6C,0xC7,0xE7,0x4E,0xC9,0x51,0xD1,0xC9,0x82,0x2C,0x38,0x57,0x6F,0xEB,0x73,0xBC};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^133)*G
			{
				const static sl_uint8 _x[] = {0x4B,0x30,0xCB,0xB7,0x68,0x67,0x73,0xE0,0x1E,0xC6,0x41,0x10,0xAB,0xDB,0x36,0x2F,0x88,0x53,0x1A,0x82,0x5B,0xA1,0x72,0x95,0x3B,0xFE,0xE2,0x23,0x3B,0xCD,0xAF,0x2F};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x74,0xC6,0x35,0x02,0x65,0xBB,0x62,0x9B,0x6F,0x9E,0x2C,0x57,0x77,0xC3,0xC4,0xA9,0x1F,0xDF,0x3C,0x81,0xE4,0x34,0x85,0x75,0x68,0x03,0x3D,0x46,0x3D,0x26,0xB5,0xB7};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^134)*G
			{
				const static sl_uint8 _x[] = {0xCB,0xB4,0x34,0xAA,0x7A,0xE1,0x70,0x0D,0xCD,0x15,0xB2,0x0B,0x17,0x46,0x48,0x17,0xEC,0x11,0x71,0x50,0x50,0xE0,0xFA,0x19,0x2F,0xFE,0x9C,0x29,0xA6,0x73,0x05,0x9F};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x4A,0x1A,0x20,0x0A,0xB4,0xDA,0xBD,0x17,0x56,0x2D,0x49,0x23,0x38,0xB5,0xDF,0xAD,0x41,0xD4,0x5E,0x4F,0x0A,0xD5,0xF8,0x45,0xB7,0xDA,0x96,0x42,0x22,0x7C,0x07,0x0C};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^135)*G
			{
				const static sl_uint8 _x[] = {0xF4,0x78,0x05,0x6D,0x9C,0x10,0x2C,0x1C,0xD0,0x6D,0x7B,0x1E,0x75,0x57,0x24,0x4C,0x6D,0x9C,0xDA,0xC5,0x87,0x46,0x10,0xE9,0x4D,0x47,0x86,0xE1,0x06,0xDE,0x12,0xC0};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x7F,0x09,0xE6,0x10,0xF3,0x3E,0x39,0x46,0xE6,0x80,0x95,0xE0,0x10,0x68,0x69,0x4C,0x26,0xC1,0x7E,0xF6,0x09,0xAB,0x92,0xD7,0x69,0xA7,0x6C,0xE6,0xCA,0x53,0x61,0xFE};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^136)*G
			{
				const static sl_uint8 _x[] = {0x8C,0x00,0xFA,0x9B,0x18,0xEB,0xF3,0x31,0xEB,0x96,0x15,0x37,0xA4,0x5A,0x42,0x66,0xC7,0x03,0x4F,0x2F,0x0D,0x4E,0x1D,0x07,0x16,0xFB,0x6E,0xAE,0x20,0xEA,0xE2,0x9E};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xEF,0xA4,0x72,0x67,0xFE,0xA5,0x21,0xA1,0xA9,0xDC,0x34,0x3A,0x37,0x36,0xC9,0x74,0xC2,0xFA,0xDA,0xFA,0x81,0xE3,0x6C,0x54,0xE7,0xD2,0xA4,0xC6,0x67,0x02,0x41,0x4B};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^137)*G
			{
				const static sl_uint8 _x[] = {0x24,0xCF,0xC0,0x17,0x6D,0xA2,0xB4,0x6F,0xA8,0xBB,0x5B,0xF9,0x63,0x6B,0xE1,0xEF,0xFD,0x7E,0x29,0x7F,0x29,0x12,0x2F,0xB3,0xE8,0x4C,0x9A,0xB0,0xC1,0x8A,0xDA,0x5F};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xEB,0xFF,0x8F,0xBB,0x07,0x9C,0x61,0xA6,0x98,0x68,0x71,0x4D,0x5D,0xED,0xA9,0x27,0xED,0x95,0x9C,0xA1,0xA4,0xF8,0x14,0xF2,0x68,0xFA,0x61,0x39,0x97,0x8A,0x58,0x6B};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^138)*G
			{
				const static sl_uint8 _x[] = {0x4A,0x7D,0x58,0xD4,0xB9,0xBC,0x82,0xEA,0x2D,0xED,0x72,0xA1,0x29,0x2E,0xC6,0x16,0xDD,0xD6,0x7F,0xC7,0xF0,0x57,0xED,0xF1,0x03,0x18,0x95,0x94,0x67,0x9D,0xA2};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xB9,0x8A,0xC5,0xB7,0x67,0x02,0xCB,0x75,0xE6,0xB1,0xD8,0x14,0x7E,0xC7,0x1B,0x3B,0x71,0xC3,0xB4,0x94,0x96,0x3F,0xA2,0x8A,0x48,0x77,0xF4,0x84,0x77,0x9F,0xFE,0x26};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^139)*G
			{
				const static sl_uint8 _x[] = {0xEE,0x7D,0x69,0xC4,0xCB,0xD0,0x01,0xC7,0xFC,0x76,0xC5,0xE2,0xC0,0x66,0xCE,0x49,0x96,0xF8,0x80,0x8A,0x1E,0x07,0xB2,0xA9,0xCC,0xF3,0x4E,0xAD,0xC8,0x7C,0x4B,0x65};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xEC,0xC8,0x62,0x6E,0xC1,0xA4,0x13,0x82,0x1A,0x19,0x2A,0xBF,0x03,0x0F,0x2E,0xE2,0xC3,0x3E,0x89,0x99,0xBA,0xE9,0x42,0xE5,0x23,0xE8,0xF4,0x4E,0xD1,0x36,0xA9,0x5A};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^140)*G
			{
				const static sl_uint8 _x[] = {0xE7,0xA2,0x6C,0xE6,0x9D,0xD4,0x82,0x9F,0x3E,0x10,0xCE,0xC0,0xA9,0xE9,0x8E,0xD3,0x14,0x3D,0x08,0x4F,0x30,0x8B,0x92,0xC0,0x99,0x7F,0xDD,0xFC,0x60,0xCB,0x3E,0x41};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x2A,0x75,0x8E,0x30,0x0F,0xA7,0x98,0x4B,0x47,0x1B,0x00,0x6A,0x1A,0xAF,0xBB,0x18,0xD0,0xA6,0xB2,0xC0,0x42,0x0E,0x83,0xE2,0x0E,0x8A,0x94,0x21,0xCF,0x2C,0xFD,0x51};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^141)*G
			{
				const static sl_uint8 _x[] = {0xF5,0xCA,0xFA,0xBA,0x03,0x6B,0xF8,0xD0,0x0D,0x38,0xBF,0xB6,0x77,0x20,0x89,0xF5,0x20,0x3C,0x35,0xE4,0xD6,0xE3,0x2F,0xA9,0xD9,0x7E,0x5B,0x91,0x7B,0x4A,0xE8,0x61};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x19,0xE8,0x3B,0x8A,0x02,0x2A,0x6D,0x81,0x7B,0xFF,0x99,0x04,0x64,0x08,0x39,0x15,0x9B,0x3B,0x2A,0x9C,0x55,0x2F,0x05,0xF3,0xCC,0x9C,0x23,0x9C,0x0D,0x82,0x23,0x9C};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^142)*G
			{
				const static sl_uint8 _x[] = {0xE9,0x38,0x90,0x24,0xCE,0xB6,0x3F,0x1F,0x12,0xDF,0x51,0x56,0xD7,0xE8,0x05,0x42,0x8F,0x9E,0x50,0x9C,0x49,0x4C,0x98,0x20,0x84,0xFD,0x4C,0xD7,0xBD,0x2A,0x96,0x51};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x86,0x48,0x68,0x87,0x23,0x72,0x65,0x95,0xF9,0x28,0x7A,0xBA,0xF6,0x71,0xAA,0xF1,0x8D,0x71,0x10,0xCE,0xC6,0x77,0x0B,0xFE,0xFE,0xFD,0xE2,0xB7,0x5E,0x78,0x68,0x24};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^143)*G
			{
				const static sl_uint8 _x[] = {0x26,0x45,0x59,0xD8,0x78,0x29,0x25,0x6B,0xED,0x11,0x69,0x00,0xD8,0x2D,0x0C,0x37,0x9F,0x0E,0x4D,0x12,0x53,0xC6,0x8E,0x6F,0xCF,0x2D,0x41,0xAE,0x7C,0xDD,0xAB,0x8B};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x79,0xE5,0xBD,0x19,0x26,0xD3,0x51,0x2C,0xEF,0x7B,0xC6,0x37,0x03,0x40,0x72,0xD7,0x7A,0x86,0x31,0xAF,0x39,0xCA,0xF1,0xE6,0xC9,0xF6,0x4B,0x45,0x00,0x1D,0xE4,0x73};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^144)*G
			{
				const static sl_uint8 _x[] = {0xB6,0x45,0x9E,0x0E,0xE3,0x66,0x2E,0xC8,0xD2,0x35,0x40,0xC2,0x23,0xBC,0xBD,0xC5,0x71,0xCB,0xCB,0x96,0x7D,0x79,0x42,0x4F,0x3C,0xF2,0x9E,0xB3,0xDE,0x6B,0x80,0xEF};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x06,0x7C,0x87,0x6D,0x06,0xF3,0xE0,0x6D,0xE1,0xDA,0xDF,0x16,0xE5,0x66,0x1D,0xB3,0xC4,0xB3,0xAE,0x6D,0x48,0xE3,0x5B,0x2F,0xF3,0x0B,0xF0,0xB6,0x1A,0x71,0xBA,0x45};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^145)*G
			{
				const static sl_uint8 _x[] = {0xE5,0xD8,0xE8,0xF0,0xD9,0x82,0x3C,0x88,0xE4,0xD3,0x6F,0x73,0x01,0xF4,0x15,0x93,0xB6,0x89,0x05,0x76,0xBE,0x79,0xC2,0x11,0x25,0x3E,0xF3,0x75,0x03,0x3E,0xB5,0x1F};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x4D,0xC1,0xE9,0xB7,0x86,0x1E,0x3E,0x04,0xAB,0xB1,0x6A,0x57,0xD8,0xFE,0xEE,0xF0,0xE5,0x09,0xDC,0x46,0xD9,0xF0,0xF5,0x49,0x79,0xD5,0xBD,0x96,0x5A,0x62,0xA2,0xD9};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^146)*G
			{
				const static sl_uint8 _x[] = {0xA9,0xCA,0x27,0xF7,0x7D,0xBC,0x8C,0x3D,0xC5,0x6B,0x0F,0x73,0x21,0xBA,0xE0,0xDD,0xAB,0x66,0xBE,0x4F,0xA8,0xA3,0x01,0x17,0x37,0xA6,0x76,0x48,0x0F,0x15,0x5E,0x64};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xF4,0xBB,0x33,0x56,0x78,0xFB,0x14,0xD4,0xD1,0x97,0xD2,0x24,0x6C,0x02,0xD0,0x04,0x87,0x5D,0x41,0x82,0x1B,0xCA,0xF0,0xAE,0x1F,0x3F,0x33,0x3C,0x56,0x1B,0x32,0x97};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^147)*G
			{
				const static sl_uint8 _x[] = {0x68,0xFB,0x71,0x80,0x06,0x86,0xD7,0xF2,0x5E,0xBA,0x10,0x56,0x11,0xCF,0xE7,0x59,0x1F,0x47,0x8E,0x84,0x7F,0x51,0xCE,0xE0,0x6D,0x4B,0xC6,0x29,0xD6,0xEE,0x24,0x7C};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xCD,0x12,0xD2,0x34,0x62,0xDD,0x96,0x36,0x73,0x73,0x54,0x27,0x50,0x1B,0x0C,0x07,0x9A,0x8D,0x58,0x0B,0x04,0xC7,0x3C,0x9D,0xAE,0x1F,0x82,0x2D,0x1A,0x01,0x86,0x5D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^148)*G
			{
				const static sl_uint8 _x[] = {0xD6,0x8A,0x80,0xC8,0x28,0x0B,0xB8,0x40,0x79,0x32,0x34,0xAA,0x11,0x8F,0x06,0x23,0x1D,0x6F,0x1F,0xC6,0x7E,0x73,0xC5,0xA5,0xDE,0xDA,0x0F,0x5B,0x49,0x69,0x43,0xE8};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xDB,0x8B,0xA9,0xFF,0xF4,0xB5,0x86,0xD0,0x0C,0x4B,0x1F,0x91,0x77,0xB0,0xE2,0x8B,0x5B,0x0E,0x7B,0x8F,0x78,0x45,0x29,0x5A,0x29,0x4C,0x84,0x26,0x6B,0x13,0x31,0x20};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^149)*G
			{
				const static sl_uint8 _x[] = {0xF1,0x6A,0x40,0x9C,0x67,0x7A,0x40,0xBE,0x40,0x2F,0x8E,0xFB,0x37,0x52,0x37,0x3C,0xAC,0xED,0x05,0x3C,0x6F,0x70,0x2B,0x82,0x8B,0xDA,0x22,0x2C,0xA4,0x12,0xB6,0xFD};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x2A,0x41,0x31,0x17,0x14,0x53,0x27,0x99,0xD7,0xA6,0xA7,0x5A,0x74,0xE3,0x0E,0x4E,0x16,0x54,0x06,0x59,0x24,0x9E,0xBC,0xA4,0x26,0x8D,0xAE,0x77,0xEC,0xA0,0x52,0xDA};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^150)*G
			{
				const static sl_uint8 _x[] = {0x41,0x54,0xB5,0x06,0xAB,0x76,0x6F,0x42,0xFB,0xE3,0x7F,0x69,0x99,0x76,0xF8,0x4D,0xB8,0x9F,0x4F,0x2F,0x6B,0xED,0x98,0x32,0x5C,0x1A,0x0B,0x6E,0x32,0x6D,0xD4,0xE4};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x23,0xAD,0x07,0x50,0x43,0xC5,0x98,0x88,0x94,0xC6,0xE4,0x4D,0x61,0x02,0x5F,0xF6,0x41,0x4E,0xA9,0xD9,0xD1,0xE2,0x2D,0xD4,0x6C,0x85,0x92,0x95,0x07,0x5D,0xED,0x1C};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^151)*G
			{
				const static sl_uint8 _x[] = {0xB7,0x3C,0x65,0x27,0x69,0xCC,0x95,0xC1,0x08,0x0A,0x8D,0x4D,0x0B,0x59,0x56,0xEA,0x93,0xE8,0x6E,0x49,0xFC,0x72,0x7D,0xDF,0x4C,0x51,0xA7,0xA6,0x3F,0x7F,0x02,0x46};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x9A,0x67,0xDB,0x10,0x71,0x74,0xCA,0x9D,0x4B,0x53,0x58,0x93,0xC5,0xB6,0xC1,0xEA,0x1A,0x0D,0x72,0xE4,0xC6,0xE5,0x54,0xE5,0x59,0x7E,0x51,0x64,0xEA,0x2A,0x40,0x7B};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^152)*G
			{
				const static sl_uint8 _x[] = {0x32,0x4A,0xED,0x7D,0xF6,0x5C,0x80,0x42,0x52,0xDC,0x02,0x70,0x90,0x7A,0x30,0xB0,0x96,0x12,0xAE,0xB9,0x73,0x44,0x9C,0xEA,0x40,0x95,0x98,0x0F,0xC2,0x8D,0x3D,0x5D};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x64,0x8A,0x36,0x57,0x74,0xB6,0x1F,0x2F,0xF1,0x30,0xC0,0xC3,0x5A,0xEC,0x1F,0x4F,0x19,0x21,0x3B,0x0C,0x7E,0x33,0x28,0x43,0x96,0x72,0x24,0xAF,0x96,0xAB,0x7C,0x84};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^153)*G
			{
				const static sl_uint8 _x[] = {0x32,0xC9,0x33,0x1E,0xA2,0x6F,0x49,0x02,0x28,0xD3,0x26,0x81,0x88,0x0D,0x72,0x03,0xF7,0x2B,0x3E,0x4A,0x8D,0xE0,0xDB,0x1F,0xA8,0xF3,0x83,0x81,0xB2,0x91,0x97,0x49};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xD7,0xCD,0x27,0x2B,0x34,0x20,0x9C,0xB5,0x69,0x5A,0x2F,0x02,0xB6,0xF3,0xDB,0xB8,0x26,0x8A,0x4A,0xBD,0xAE,0x39,0xAB,0x09,0x63,0x1E,0x97,0xB0,0xF2,0x90,0xB5,0xE3};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^154)*G
			{
				const static sl_uint8 _x[] = {0xEB,0x29,0x2F,0x3B,0x3B,0x98,0x37,0x85,0x4A,0x02,0xF6,0xA7,0x0F,0xEC,0x6B,0x1C,0x69,0xC1,0x61,0xB6,0xE1,0x84,0x6B,0x8E,0x1E,0x1C,0x22,0x52,0x7B,0x97,0x95,0xE4};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x8C,0x43,0xC2,0x5A,0x96,0xEE,0xBE,0x80,0x16,0x96,0x63,0x4A,0xF1,0x45,0x83,0x5B,0x57,0x13,0x1D,0x75,0x09,0x11,0x1C,0x6F,0x5B,0x7E,0x9D,0x2F,0xAE,0x53,0xA0,0xFE};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^155)*G
			{
				const static sl_uint8 _x[] = {0xA6,0x5A,0x3A,0x01,0xDF,0x3B,0x5E,0xF2,0xE6,0x20,0xD4,0x31,0x00,0x49,0xFB,0xE1,0x4D,0x71,0x45,0x7F,0x19,0xD1,0xED,0x35,0xAE,0xA3,0x9D,0x57,0x89,0x30,0x3F,0xDD};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x79,0x8E,0xA0,0x94,0x0C,0xFF,0x5C,0x6F,0xB8,0xF4,0x3D,0x8D,0x90,0xED,0x2C,0x76,0x86,0x86,0x1D,0x02,0x4F,0xAE,0xD3,0xCA,0xDA,0xD4,0x4A,0x8D,0x02,0xE6,0x87,0x03};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^156)*G
			{
				const static sl_uint8 _x[] = {0x4D,0xF9,0xC1,0x49,0x19,0xCD,0xE6,0x1F,0x6D,0x51,0xDF,0xDB,0xE5,0xFE,0xE5,0xDC,0xEE,0xC4,0x14,0x3B,0xA8,0xD1,0xCA,0x88,0x8E,0x8B,0xD3,0x73,0xFD,0x05,0x4C,0x96};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x35,0xEC,0x51,0x09,0x2D,0x87,0x28,0x05,0x09,0x74,0xC2,0x3A,0x1D,0x85,0xD4,0xB5,0xD5,0x06,0xCD,0xC2,0x88,0x49,0x01,0x92,0xEB,0xAC,0x06,0xCA,0xD1,0x0D,0x5D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^157)*G
			{
				const static sl_uint8 _x[] = {0xED,0x32,0xCA,0xD8,0xD2,0xCC,0x99,0x8C,0xD2,0x53,0x17,0xD4,0xE4,0xB8,0x70,0x88,0xE9,0xDE,0x45,0x54,0xE5,0x7A,0x8D,0x70,0xC0,0xC6,0xB0,0xFC,0x1D,0xA4,0x9E,0x04};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x12,0x9F,0xEF,0x5F,0x1D,0x03,0x02,0x04,0xA5,0x41,0xCA,0x37,0x58,0x59,0xD2,0x0B,0x52,0xDA,0x9F,0xAC,0xB4,0x9F,0xAB,0x7D,0xB6,0x31,0x20,0xD1,0x7C,0x1D,0xB9,0xE0};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^158)*G
			{
				const static sl_uint8 _x[] = {0xE8,0x21,0xAB,0x72,0x4D,0x63,0x60,0xF1,0x80,0x49,0xE4,0x11,0x1C,0x70,0x36,0x6E,0x28,0xC3,0x6D,0xCB,0x63,0xC3,0x40,0x16,0xCB,0x74,0x18,0xD4,0xE8,0x83,0xF8,0x55};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xAD,0xEF,0xCB,0xF8,0x63,0xF5,0x3C,0xE3,0x67,0xD0,0xD4,0x11,0x54,0x16,0xCF,0x59,0x8B,0x3B,0x19,0xC6,0x14,0xEC,0x23,0xEF,0xED,0x4E,0x0C,0x6A,0x59,0x85,0x2D,0xDF};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^159)*G
			{
				const static sl_uint8 _x[] = {0x3F,0x0D,0x89,0x94,0xE5,0x1A,0xD2,0x12,0xF4,0x55,0x45,0x2F,0xBC,0x96,0x93,0xA7,0x2F,0x14,0xA5,0x47,0xAF,0x38,0x06,0xE9,0xFB,0xFF,0x59,0xEE,0xB4,0x41,0x74,0x2E};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xFB,0xD7,0x6C,0x23,0xF2,0x8C,0x3D,0xC4,0x45,0xE5,0xCB,0x0E,0x84,0x7A,0x6E,0x0B,0x1E,0x20,0x5E,0x2C,0x3A,0xD1,0x3D,0x95,0x8C,0x65,0x36,0x3B,0xCF,0xEC,0xAD,0xBE};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^160)*G
			{
				const static sl_uint8 _x[] = {0x9C,0x39,0x19,0xA8,0x4A,0x47,0x48,0x70,0xFA,0xED,0x8A,0x9C,0x1C,0xC6,0x60,0x21,0x52,0x34,0x89,0x05,0x4D,0x7F,0x03,0x08,0xCB,0xFC,0x99,0xC8,0xAC,0x1F,0x98,0xCD};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xDD,0xB8,0x4F,0x0F,0x4A,0x4D,0xDD,0x57,0x58,0x4F,0x04,0x4B,0xF2,0x60,0xE6,0x41,0x90,0x53,0x26,0xF7,0x6C,0x64,0xC8,0xE6,0xBE,0x7E,0x5E,0x03,0xD4,0xFC,0x59,0x9D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^161)*G
			{
				const static sl_uint8 _x[] = {0x2E,0x3C,0x05,0x32,0x62,0x55,0xD8,0x0F,0x0A,0x42,0xFC,0x69,0xD5,0xC9,0x2A,0xA4,0x0C,0xD3,0x26,0xA5,0x3E,0x85,0x35,0xF0,0x43,0x5E,0xFB,0x7B,0x69,0x4A,0x09,0xEC};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x1F,0xF8,0x91,0x65,0x6C,0x6F,0xB5,0xBD,0xDA,0xE2,0x40,0xB8,0x2F,0xC1,0xAB,0xE0,0x48,0xA5,0x3C,0x70,0x7B,0x66,0x51,0x25,0x34,0x86,0x81,0x88,0xC7,0x32,0x7E};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^162)*G
			{
				const static sl_uint8 _x[] = {0xE8,0xE2,0xA2,0x4C,0xCF,0xA4,0x15,0x87,0xAE,0x15,0xFB,0x7E,0x3E,0x24,0xDD,0xA4,0x33,0x71,0x03,0x16,0xA1,0x90,0x89,0x34,0x20,0x5F,0x19,0xA2,0xAB,0x9C,0x7C,0xE6};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x46,0xC9,0x83,0xCE,0x0C,0x6F,0x5D,0x1B,0x4C,0xAF,0x2B,0x2B,0x3B,0xEE,0x20,0x59,0x6E,0x09,0xE6,0x03,0xB5,0xC2,0x7A,0x73,0xB2,0xC0,0x1E,0xB6,0x88,0x36,0x26,0x7C};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^163)*G
			{
				const static sl_uint8 _x[] = {0xA7,0x54,0x9A,0xAC,0x5D,0x85,0x73,0xC2,0xB2,0xF0,0xA3,0x8B,0x17,0x00,0x32,0xA2,0x12,0xAC,0xAF,0x92,0x38,0x3D,0x5B,0x5F,0x5B,0x0D,0x39,0x66,0x8A,0xC7,0xB3,0xC2};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xBD,0x17,0xD1,0xB9,0x0D,0x1C,0x24,0x15,0x33,0x5A,0x1D,0x70,0xC1,0x94,0x7D,0x2B,0x5D,0x6B,0x51,0x15,0x53,0x71,0x16,0xDF,0xFA,0x0C,0x91,0x71,0x92,0x87,0xEA,0xEF};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^164)*G
			{
				const static sl_uint8 _x[] = {0x60,0x57,0x17,0x0B,0x1D,0xD1,0x2F,0xDF,0x8D,0xE0,0x5F,0x28,0x1D,0x8E,0x06,0xBB,0x91,0xE1,0x49,0x3A,0x8B,0x91,0xD4,0xCC,0x5A,0x21,0x38,0x21,0x20,0xA9,0x59,0xE5};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x9A,0x1A,0xF0,0xB2,0x6A,0x6A,0x48,0x07,0xAD,0xD9,0xA2,0xDA,0xF7,0x1D,0xF2,0x62,0x46,0x51,0x52,0xBC,0x3E,0xE2,0x4C,0x65,0xE8,0x99,0xBE,0x93,0x23,0x85,0xA2,0xA8};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^165)*G
			{
				const static sl_uint8 _x[] = {0x67,0x73,0xFD,0x67,0x7C,0x52,0xE0,0x64,0x03,0x94,0x11,0x0A,0x46,0xDC,0x85,0xDF,0x7C,0x13,0x3F,0x8D,0xD4,0xA2,0x8E,0x66,0x18,0x99,0xCA,0x5D,0x82,0xFD,0x54,0x5C};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x44,0x4E,0xB6,0xD8,0xCD,0x97,0x65,0x2F,0x0F,0x0F,0x25,0xC9,0xDD,0x2B,0x24,0x6B,0xEA,0xD7,0x80,0xF5,0xA1,0xC6,0xCF,0x98,0xE8,0xC7,0xF0,0x34,0x94,0x7E,0xB1,0xAE};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^166)*G
			{
				const static sl_uint8 _x[] = {0xE0,0xF8,0x6D,0x94,0xD1,0x7C,0xE5,0x65,0x23,0x7C,0x79,0xAA,0xCE,0x0C,0x87,0xC2,0x03,0x74,0xE4,0x38,0x10,0x46,0x80,0x50,0x37,0x3C,0x61,0x6B,0x0B,0x86,0xF0,0x21};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x0C,0x57,0x1C,0x73,0x73,0x0A,0xBC,0xF4,0x7A,0x91,0xE8,0x32,0xF1,0xC8,0x9A,0x2C,0x9A,0x80,0xBC,0xC0,0x11,0x5F,0xC4,0x5B,0x3B,0x6B,0x79,0xCC,0xB5,0xBF,0x32,0x5A};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^167)*G
			{
				const static sl_uint8 _x[] = {0x42,0xCA,0x15,0xAB,0x9F,0x24,0x50,0x41,0xCE,0x99,0x1E,0x19,0x3D,0x69,0x6F,0x4F,0x4C,0x27,0x7D,0xF9,0x08,0xCA,0xD6,0x03,0x8A,0xD0,0x77,0x2C,0x02,0xDA,0x6E,0x03};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x68,0xD2,0xEF,0x26,0xC8,0x1C,0x57,0xC9,0x64,0x7C,0xE4,0xD1,0xFC,0xB8,0x00,0xEE,0xD6,0x6E,0x85,0xA6,0x81,0x06,0xBE,0xA7,0x83,0x68,0x89,0xFA,0x8C,0x34,0x77,0x93};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^168)*G
			{
				const static sl_uint8 _x[] = {0xA5,0x76,0xDF,0x8E,0x23,0xA0,0x84,0x11,0x42,0x14,0x39,0xA4,0x51,0x8D,0xA3,0x18,0x80,0xCE,0xF0,0xFB,0xA7,0xD4,0xDF,0x12,0xB1,0xA6,0x97,0x3E,0xEC,0xB9,0x42,0x66};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x40,0xA6,0xBF,0x20,0xE7,0x66,0x40,0xB2,0xC9,0x2B,0x97,0xAF,0xE5,0x8C,0xD8,0x2C,0x43,0x2E,0x10,0xA7,0xF5,0x14,0xD9,0xF3,0xEE,0x8B,0xE1,0x1A,0xE1,0xB2,0x8E,0xC8};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^169)*G
			{
				const static sl_uint8 _x[] = {0x9E,0x5D,0xCC,0x62,0xEF,0x3B,0x5A,0x3B,0x54,0x65,0x20,0x86,0x7B,0xE7,0x1B,0xAE,0x6F,0x3B,0xA0,0x63,0xC9,0xAC,0xFB,0x8D,0xCE,0xC5,0x72,0x5B,0xDA,0x70,0x48,0x96};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x6F,0xED,0xD1,0x2D,0xDB,0x92,0x5F,0x3E,0xA5,0xFD,0x3A,0x21,0x54,0xC7,0x61,0x22,0x79,0x60,0x5D,0x18,0x60,0x30,0xF5,0x12,0x48,0xF2,0x76,0x9D,0xCA,0x82,0xC8,0x35};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^170)*G
			{
				const static sl_uint8 _x[] = {0xA7,0xDE,0x08,0x37,0x5B,0x87,0x45,0xAD,0xF8,0xD6,0xE9,0xF9,0x76,0xF0,0x3B,0x20,0xE3,0x36,0x25,0xA0,0x5C,0xEF,0x58,0x33,0x95,0x3E,0xD5,0x87,0x44,0xBF,0x7E,0xA0};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xA6,0x3D,0x96,0xB0,0x57,0xAD,0xA5,0xE5,0x21,0x04,0xA0,0xB3,0x34,0x88,0x8E,0x9A,0x64,0x5A,0x47,0xC0,0xFE,0xBC,0x5A,0xA2,0xE0,0x4C,0x05,0x53,0x9B,0xBC,0xAB,0xAA};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^171)*G
			{
				const static sl_uint8 _x[] = {0xC2,0x66,0x65,0x8E,0x68,0x90,0x80,0xC9,0xC1,0x3C,0x35,0xAC,0x01,0xCF,0xF4,0xCB,0xE6,0x80,0x65,0xFD,0xE9,0x49,0xE4,0xA3,0xA9,0xF8,0xFA,0x10,0x4A,0xD9,0x16,0xFB};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xE7,0xE8,0x59,0x38,0x54,0xE7,0xDA,0xAB,0x0F,0x79,0x81,0x70,0xB2,0x46,0x27,0xAB,0x6B,0x8F,0xEC,0xDF,0xEB,0x61,0x13,0x88,0x56,0xAE,0xF5,0x2B,0xA0,0x88,0x78,0x14};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^172)*G
			{
				const static sl_uint8 _x[] = {0x77,0x78,0xA7,0x8C,0x28,0xDE,0xC3,0xE3,0x0A,0x05,0xFE,0x96,0x29,0xDE,0x8C,0x38,0xBB,0x30,0xD1,0xF5,0xCF,0x9A,0x3A,0x20,0x8F,0x76,0x38,0x89,0xBE,0x58,0xAD,0x71};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x34,0x62,0x6D,0x9A,0xB5,0xA5,0xB2,0x2F,0xF7,0x09,0x8E,0x12,0xF2,0xFF,0x58,0x00,0x87,0xB3,0x84,0x11,0xFF,0x24,0xAC,0x56,0x3B,0x51,0x3F,0xC1,0xFD,0x9F,0x43,0xAC};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^173)*G
			{
				const static sl_uint8 _x[] = {0xE7,0xB9,0x79,0x6B,0x5C,0xA0,0x06,0xD1,0x63,0x2F,0x48,0x2D,0x7F,0x0F,0xE3,0x93,0x2C,0xF1,0x6A,0x5A,0xE1,0x04,0xEE,0xA7,0xA7,0xEA,0x1C,0x25,0x10,0x73,0xE8,0x79};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x12,0xB8,0x98,0x8C,0x19,0x16,0x9E,0x2F,0xDF,0x42,0x10,0x2A,0x73,0x7C,0xC1,0xCA,0x9C,0xB5,0xBF,0x25,0xED,0xA9,0x8A,0xF3,0x38,0xE7,0x10,0x89,0xBA,0xA8,0x9D,0x98};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^174)*G
			{
				const static sl_uint8 _x[] = {0x07,0x1B,0xF0,0x18,0x50,0x87,0x62,0x03,0xC2,0xC9,0x15,0xA2,0x4B,0xE0,0x9A,0x73,0x65,0x42,0x3D,0xAA,0xF2,0xAE,0xE9,0x19,0x86,0x5D,0x72,0x2B,0xF2,0x62,0x8F,0x0F};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x52,0x7A,0xA1,0x5D,0x50,0x4D,0xCF,0x4A,0xE3,0x36,0x00,0xBC,0x1C,0x08,0x4C,0xE2,0x09,0x8F,0x9C,0x6A,0x23,0x1C,0x80,0xBB,0xB5,0x7C,0x5C,0xBD,0x45,0xA1,0xC3,0x34};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^175)*G
			{
				const static sl_uint8 _x[] = {0x02,0x18,0x34,0x3A,0xCB,0x9B,0xE5,0x68,0x33,0xA3,0x2E,0x59,0x4C,0x03,0xC3,0x9E,0x5B,0x19,0x11,0xC8,0x50,0x12,0x13,0x78,0x6F,0x63,0x76,0xDF,0xA3,0x96,0x20,0xE1};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xBE,0xA8,0x1D,0x48,0x97,0x0A,0x50,0xBE,0xAF,0x3F,0x24,0xFD,0x60,0x2F,0xBF,0xC0,0x44,0x32,0x99,0xA4,0x2F,0x43,0xC9,0xEC,0x5E,0x01,0x99,0xF6,0x50,0x69,0x98,0xB5};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^176)*G
			{
				const static sl_uint8 _x[] = {0x09,0x28,0x95,0x5E,0xE6,0x37,0xA8,0x44,0x63,0x72,0x9F,0xD3,0x0E,0x7A,0xFD,0x2E,0xD5,0xF9,0x62,0x74,0xE5,0xAD,0x7E,0x5C,0xB0,0x9E,0xDA,0x9C,0x06,0xD9,0x03,0xAC};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xC2,0x56,0x21,0x00,0x3D,0x3F,0x42,0xA8,0x27,0xB7,0x8A,0x13,0x09,0x3A,0x95,0xEE,0xAC,0x3D,0x26,0xEF,0xA8,0xA8,0xD8,0x3F,0xC5,0x18,0x0E,0x93,0x5B,0xCD,0x09,0x1F};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^177)*G
			{
				const static sl_uint8 _x[] = {0x4F,0x89,0xBD,0xEE,0x37,0x71,0xD3,0x50,0xDA,0xD1,0x63,0xB0,0x4C,0xB1,0x8A,0xD6,0x7C,0xE5,0xE9,0xC5,0x5B,0x58,0xF0,0xE7,0x23,0x10,0x47,0xA6,0x0F,0x59,0xDD,0x9E};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xCA,0x79,0x52,0xD5,0x22,0x7A,0x1F,0x69,0x5C,0x4B,0xAF,0x4C,0x04,0x3B,0xB2,0x47,0x1E,0x48,0x82,0x50,0x66,0x38,0xDF,0x5C,0x10,0x16,0xAE,0x32,0x01,0x56,0xB0,0x49};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^178)*G
			{
				const static sl_uint8 _x[] = {0xCB,0x9E,0x83,0x04,0xCA,0xE3,0xC5,0xA8,0x0C,0x39,0x6B,0xAC,0xA2,0xC3,0xC4,0xC9,0x94,0xB6,0x68,0xF0,0x79,0xA2,0x45,0xBF,0x52,0x9C,0x31,0x4C,0xFF,0xF0,0x11,0x97};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x62,0xC7,0xD2,0x80,0x1E,0xB8,0x0E,0x6A,0x12,0x72,0x58,0xCD,0xFF,0x08,0x89,0x17,0x41,0xB2,0xD1,0x8C,0x01,0x5E,0x0A,0x24,0xC3,0x34,0xE0,0x76,0x3B,0x98,0x9C,0x1D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^179)*G
			{
				const static sl_uint8 _x[] = {0xE2,0xF3,0x49,0xB0,0xF8,0x9C,0x69,0xBD,0x3C,0x8C,0xF2,0xA4,0x10,0x73,0x0D,0xC5,0x8E,0x0B,0xEE,0xD4,0x70,0x48,0xC5,0x8C,0x15,0xF9,0xFF,0xC2,0x50,0x8D,0x2C,0xC2};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x1F,0xEB,0x2F,0x28,0x0F,0x82,0x72,0x37,0x81,0x86,0x0A,0xEC,0x76,0x02,0x15,0xBA,0x42,0x34,0x4B,0xE8,0xE0,0x9C,0xBD,0xB3,0x7E,0x34,0x7B,0xD8,0xE0,0xD4,0xC0,0x4F};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^180)*G
			{
				const static sl_uint8 _x[] = {0x85,0xD0,0xFE,0xF3,0xEC,0x6D,0xB1,0x09,0x39,0x90,0x64,0xF3,0xA0,0xE3,0xB2,0x85,0x56,0x45,0xB4,0xA9,0x07,0xAD,0x35,0x45,0x27,0xAA,0xE7,0x51,0x63,0xD8,0x27,0x51};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x1F,0x03,0x64,0x84,0x13,0xA3,0x8C,0x0B,0xE2,0x9D,0x49,0x6E,0x58,0x2C,0xF5,0x66,0x3E,0x87,0x51,0xE9,0x68,0x77,0x33,0x15,0x82,0xC2,0x37,0xA2,0x4E,0xB1,0xF9,0x62};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^181)*G
			{
				const static sl_uint8 _x[] = {0x6B,0x79,0x0F,0x4B,0x19,0xA4,0xC4,0xF4,0xF6,0x07,0xA6,0xCF,0xCD,0x11,0xDF,0x04,0x68,0xB4,0x82,0xE0,0x09,0x71,0x1F,0xF7,0x56,0x35,0x6D,0x14,0x1D,0x5F,0xCA,0xDE};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xD0,0x3A,0x98,0x1B,0x2F,0xF9,0xEB,0x3E,0xF2,0x96,0x66,0x1F,0x9C,0xAE,0x09,0xCB,0xA8,0x3F,0xA5,0xB4,0x7B,0xE2,0x6B,0x0A,0xB6,0xFF,0xF8,0x6F,0xC3,0x38,0xD3,0xFF};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^182)*G
			{
				const static sl_uint8 _x[] = {0x41,0x14,0x9B,0x2C,0x2D,0x7E,0xBE,0xD3,0xC1,0x62,0xC3,0x67,0xAC,0xC4,0xF8,0xFE,0x3D,0x24,0x79,0xDE,0x85,0x97,0x8B,0xE0,0xBB,0x0C,0xCD,0xAB,0xE3,0xA3,0xE0,0xCB};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xC9,0x0D,0x5B,0x92,0xDB,0x7C,0x30,0x54,0x2B,0x41,0x5C,0x9B,0x99,0x02,0xCF,0x28,0xB3,0xEC,0x78,0x05,0xEF,0x49,0x0F,0x24,0x70,0xE9,0x2E,0x98,0x33,0x90,0x33,0xA8};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^183)*G
			{
				const static sl_uint8 _x[] = {0xD1,0xFA,0xD4,0xFA,0x4E,0x7C,0x84,0x9D,0xFA,0xEC,0x3D,0xFE,0x28,0x72,0xA7,0xBA,0x66,0x4A,0x9B,0x82,0x05,0xC2,0x9C,0xEB,0xF8,0xDD,0xDD,0x28,0xE3,0xF3,0xD3,0xFC};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x8F,0xE1,0x97,0x14,0xA3,0x48,0xFD,0xFE,0x54,0x73,0xF7,0x0E,0x85,0x8B,0x78,0x18,0xBA,0xD3,0x71,0x31,0xEF,0xF3,0x73,0x26,0xED,0x22,0x34,0x3C,0x50,0xF3,0x70,0x4D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^184)*G
			{
				const static sl_uint8 _x[] = {0xFF,0x2B,0x0D,0xCE,0x97,0xEE,0xCE,0x97,0xC1,0xC9,0xB6,0x04,0x17,0x98,0xB8,0x5D,0xFD,0xFB,0x6D,0x88,0x82,0xDA,0x20,0x30,0x8F,0x54,0x04,0x82,0x45,0x26,0x08,0x7E};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x49,0x3D,0x13,0xFE,0xF5,0x24,0xBA,0x18,0x8A,0xF4,0xC4,0xDC,0x54,0xD0,0x79,0x36,0xC7,0xB7,0xED,0x6F,0xB9,0x0E,0x2C,0xEB,0x2C,0x95,0x1E,0x01,0xF0,0xC2,0x99,0x07};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^185)*G
			{
				const static sl_uint8 _x[] = {0x29,0x82,0xDB,0xBC,0x5F,0x36,0x6C,0x9F,0x78,0xE2,0x9E,0xBB,0xEC,0xB1,0xBB,0x22,0x3D,0xEB,0x5C,0x4E,0xE6,0x38,0xB4,0x58,0x3B,0xD3,0xA9,0xAF,0x31,0x49,0xF8,0xEF};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xA6,0x1B,0x5B,0xE9,0xAF,0x66,0x22,0x0A,0xB9,0xFA,0x53,0x39,0xC7,0xB5,0xBC,0x9D,0x09,0x5D,0xB9,0x94,0x12,0xE3,0xED,0x84,0x56,0xE7,0x26,0xB0,0x16,0xC7,0xA2,0x48};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^186)*G
			{
				const static sl_uint8 _x[] = {0x1A,0x28,0xE5,0x04,0x2A,0xF0,0xC0,0xF6,0xB4,0x36,0xEB,0x59,0x04,0x97,0xDB,0x58,0x60,0x01,0x1F,0x45,0x80,0xE1,0x76,0x58,0x85,0x28,0x9F,0x61,0x23,0x80,0x44,0x1B};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x55,0x77,0x9A,0x79,0x96,0xC5,0x9D,0xAB,0x7C,0x78,0x32,0x9A,0x89,0x76,0xF0,0xED,0x04,0xB3,0xE7,0x5B,0x46,0xEE,0x67,0xAE,0xB0,0x5F,0x60,0x6A,0x84,0x52,0xAF,0x25};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^187)*G
			{
				const static sl_uint8 _x[] = {0x0C,0x8B,0x83,0xE9,0x53,0x5F,0x30,0x60,0x1D,0x25,0x0C,0xC0,0xBD,0x3F,0x20,0x14,0x2E,0xDD,0x5E,0xB7,0x98,0x5D,0x83,0x24,0x2E,0xEF,0x0E,0x39,0x62,0x1E,0x30,0xA7};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x0D,0xCC,0x70,0x77,0x06,0x5F,0xDA,0xC7,0xB8,0x50,0xE3,0xF1,0x7E,0xFD,0xC8,0x54,0xAA,0xCA,0xD2,0x37,0xB9,0x87,0x13,0x4D,0xBE,0xBF,0x7B,0xEB,0x9F,0xF6,0x88,0xDE};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^188)*G
			{
				const static sl_uint8 _x[] = {0x82,0x7F,0xBB,0xE4,0xB1,0xE8,0x80,0xEA,0x9E,0xD2,0xB2,0xE6,0x30,0x1B,0x21,0x2B,0x57,0xF1,0xEE,0x14,0x8C,0xD6,0xDD,0x28,0x78,0x0E,0x5E,0x2C,0xF8,0x56,0xE2,0x41};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xC6,0x0F,0x9C,0x92,0x3C,0x72,0x7B,0x0B,0x71,0xBE,0xF2,0xC6,0x7D,0x1D,0x12,0x68,0x7F,0xF7,0xA6,0x31,0x86,0x90,0x31,0x66,0xD6,0x05,0xB6,0x8B,0xAE,0xC2,0x93,0xEC};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^189)*G
			{
				const static sl_uint8 _x[] = {0xB7,0x7F,0x12,0xA7,0xDC,0xE5,0x6B,0x97,0x3E,0x2D,0x7C,0x8D,0x57,0x6E,0x6B,0x36,0x60,0x47,0x0A,0x92,0x18,0xB8,0x74,0x61,0xEF,0x6E,0x44,0xB7,0x0C,0xB1,0x81,0x5D};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x4B,0x6F,0x85,0xB1,0x4F,0x86,0xAC,0xC4,0x3F,0x0C,0xEF,0xB3,0x73,0xCC,0x2E,0x65,0x4C,0x42,0xF0,0xF9,0x1A,0x44,0x81,0x6D,0x6B,0xA3,0xD2,0xBC,0x8E,0x57,0xDB,0xC5};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^190)*G
			{
				const static sl_uint8 _x[] = {0x48,0x97,0x3B,0x94,0x30,0x18,0xBF,0x12,0x47,0xB3,0x08,0xB2,0xCB,0x79,0xF9,0x56,0xD8,0x58,0xD8,0xDF,0x49,0x77,0xC5,0x97,0x0F,0xE5,0xDA,0xD2,0xC4,0x55,0x65,0xEC};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x76,0x1F,0x75,0x68,0x4F,0x3C,0xDC,0x1B,0x64,0x37,0xBB,0x3A,0x01,0x44,0x5A,0xF1,0x51,0x1B,0x35,0x96,0x58,0x04,0x77,0xB8,0x3B,0x87,0x90,0x75,0xFA,0xED,0x07,0xE9};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^191)*G
			{
				const static sl_uint8 _x[] = {0xE9,0x31,0x25,0x8E,0x8E,0xB5,0x55,0x9C,0x6D,0x69,0x72,0x72,0x8A,0x70,0x4C,0x17,0x0B,0x77,0x5A,0x26,0x5B,0x45,0x27,0xD4,0xA4,0xD4,0xD7,0x42,0xBB,0xFD,0x71,0xFA};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xFB,0x1E,0x33,0x36,0x4C,0x3F,0xDE,0xE0,0xE8,0x5E,0xB4,0x16,0x9C,0x95,0x4B,0x40,0xB3,0x94,0x6C,0xE1,0xBB,0x5E,0x35,0xF3,0x3D,0x9B,0xD0,0xD3,0x17,0x4D,0x33,0x07};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^192)*G
			{
				const static sl_uint8 _x[] = {0xEA,0xA6,0x49,0xF2,0x1F,0x51,0xBD,0xBA,0xE7,0xBE,0x4A,0xE3,0x4C,0xE6,0xE5,0x21,0x7A,0x58,0xFD,0xCE,0x7F,0x47,0xF9,0xAA,0x7F,0x3B,0x58,0xFA,0x21,0x20,0xE2,0xB3};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xBE,0x32,0x79,0xED,0x5B,0xBB,0xB0,0x3A,0xC6,0x9A,0x80,0xF8,0x98,0x79,0xAA,0x5A,0x01,0xA6,0xB9,0x65,0xF1,0x3F,0x7E,0x59,0xD4,0x7A,0x53,0x05,0xBA,0x5A,0xD9,0x3D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^193)*G
			{
				const static sl_uint8 _x[] = {0x3A,0xDB,0x9D,0xB3,0xBE,0xB9,0x97,0xEE,0xC2,0x62,0x3E,0xA5,0x00,0x22,0x79,0xEA,0x9E,0x33,0x7B,0x5C,0x70,0x5F,0x3D,0xB4,0x53,0xDB,0xC1,0xCC,0x1F,0xC9,0xB0,0xA8};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x37,0x4E,0x2D,0x6D,0xAE,0xE7,0x4E,0x71,0x3C,0x77,0x4D,0xE0,0x7C,0x09,0x5F,0xF6,0xAA,0xD9,0xC8,0xF9,0x87,0x02,0x66,0xCC,0x61,0xAE,0x79,0x75,0xF0,0x5B,0xBD,0xDA};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^194)*G
			{
				const static sl_uint8 _x[] = {0x12,0x9E,0x53,0xAC,0x42,0x8E,0x9C,0xBB,0x7E,0x10,0x95,0x5E,0x56,0xC5,0xFC,0x69,0xFE,0xFD,0xFF,0x56,0x96,0x3E,0x7C,0xAF,0x05,0x4E,0x9E,0x0C,0x90,0xAE,0x86,0xF9};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x41,0x5E,0xCB,0x95,0x8A,0xEE,0x9A,0x29,0xB2,0xDA,0x21,0x15,0xB7,0x12,0x18,0x3F,0xB2,0xA2,0x32,0xFD,0x16,0xB3,0xE0,0x1B,0x82,0x2E,0xFD,0xCD,0x1E,0x89,0xC8,0x5D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^195)*G
			{
				const static sl_uint8 _x[] = {0x60,0x14,0x44,0x94,0xC8,0xF6,0x94,0x48,0x5B,0x85,0xEC,0xB6,0xAE,0xE1,0x09,0x56,0xC7,0x56,0x26,0x7D,0x12,0x89,0x47,0x11,0x92,0x22,0x43,0xD5,0xE8,0x55,0xB8,0xDA};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x8B,0xB5,0xD6,0x69,0xF6,0x81,0xE6,0x46,0x9E,0x8B,0xE1,0xFD,0x91,0x32,0xE6,0x5B,0x54,0x39,0x55,0xC2,0x7E,0x3F,0x2A,0x4B,0xAD,0x50,0x05,0x90,0xF3,0x4E,0x4B,0xBD};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^196)*G
			{
				const static sl_uint8 _x[] = {0xE4,0xA4,0x2D,0x43,0xC5,0xCF,0x16,0x9D,0x93,0x91,0xDF,0x6D,0xEC,0xF4,0x2E,0xE5,0x41,0xB6,0xD8,0xF0,0xC9,0xA1,0x37,0x40,0x1E,0x23,0x63,0x2D,0xDA,0x34,0xD2,0x4F};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x4D,0x9F,0x92,0xE7,0x16,0xD1,0xC7,0x35,0x26,0xFC,0x99,0xCC,0xFB,0x8A,0xD3,0x4C,0xE8,0x86,0xEE,0xDF,0xA8,0xD8,0xE4,0xF1,0x3A,0x7F,0x71,0x31,0xDE,0xBA,0x94,0x14};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^197)*G
			{
				const static sl_uint8 _x[] = {0xFD,0x64,0x51,0xFB,0x84,0xCF,0xB1,0x8D,0x3E,0xF0,0xAC,0xF8,0x56,0xC4,0xEF,0x4D,0x05,0x53,0xC5,0x62,0xF7,0xAE,0x4D,0x2A,0x30,0x3F,0x2E,0xA3,0x3E,0x8F,0x62,0xBB};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xE7,0x45,0xCE,0xB2,0xB1,0x87,0x15,0x78,0xB6,0xFE,0x7A,0x5C,0x1B,0xC3,0x44,0xCC,0xFA,0x2A,0xB4,0x92,0xD2,0x00,0xE8,0x3F,0xD0,0xAD,0x90,0x86,0x13,0x2C,0x09,0x11};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^198)*G
			{
				const static sl_uint8 _x[] = {0x1E,0xEE,0x20,0x7C,0xB2,0x40,0x86,0xBC,0x71,0x6E,0x81,0xA0,0x6F,0x9E,0xDB,0xBB,0x00,0x42,0xE2,0xD5,0xDC,0xF3,0xC7,0xA1,0xFA,0x1D,0x1F,0xB9,0xD5,0xFE,0x69,0x6B};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x65,0x2C,0xBD,0x19,0xAE,0xF6,0x26,0x9C,0xD2,0xB1,0x96,0xD1,0x24,0x61,0xC9,0x5F,0x7A,0x02,0x06,0x2E,0x0A,0xFD,0x69,0x4E,0xBB,0x45,0x67,0x0E,0x74,0x29,0x33,0x7B};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^199)*G
			{
				const static sl_uint8 _x[] = {0xCC,0x0E,0xA3,0x3E,0xA8,0xA9,0xEB,0x14,0xD4,0x65,0xAB,0x2C,0x34,0x6E,0x21,0x11,0xE1,0xC0,0xFC,0x01,0x7C,0x57,0x25,0x79,0x08,0xD4,0x0F,0x19,0xEF,0x94,0xC0,0xD5};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xF9,0x90,0x7A,0x3B,0x71,0x1C,0x8A,0x2F,0xB2,0x3D,0xD2,0x03,0xB5,0xFB,0xE6,0x63,0xF6,0x07,0x4F,0x26,0x61,0x13,0xF5,0x43,0xDE,0xAB,0xE5,0x97,0xAF,0x45,0x2F,0xE6};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^200)*G
			{
				const static sl_uint8 _x[] = {0x1E,0xC8,0x0F,0xEF,0x36,0x0C,0xBD,0xD9,0x54,0x16,0x0F,0xAD,0xAB,0x35,0x2B,0x6B,0x92,0xB5,0x35,0x76,0xA8,0x8F,0xEA,0x49,0x47,0x17,0x3B,0x9D,0x43,0x00,0xBF,0x19};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xAE,0xEF,0xE9,0x37,0x56,0xB5,0x34,0x0D,0x2F,0x3A,0x49,0x58,0xA7,0xAB,0xBF,0x5E,0x01,0x46,0xE7,0x7F,0x62,0x95,0xA0,0x7B,0x67,0x1C,0xDC,0x1C,0xC1,0x07,0xCE,0xFD};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^201)*G
			{
				const static sl_uint8 _x[] = {0x5B,0xE7,0xEA,0x35,0x19,0xF0,0x4B,0xC6,0xCB,0xEE,0xAA,0x03,0x44,0xFC,0x90,0xBB,0x8E,0x84,0x62,0xF6,0xEB,0xD8,0x90,0x56,0x0D,0xAE,0x80,0x5D,0x41,0x4F,0xF9,0xE4};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x32,0xF3,0x2E,0xC3,0xF6,0x38,0xE6,0x05,0x47,0x7F,0x89,0x0F,0x65,0x5A,0xB7,0xFE,0x0E,0x99,0xC6,0x30,0x21,0x19,0xA3,0x09,0x40,0x30,0xB0,0x78,0x47,0xE0,0xBD,0xBB};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^202)*G
			{
				const static sl_uint8 _x[] = {0x58,0xF0,0x99,0x11,0x6E,0xAE,0x4E,0x65,0x08,0x13,0xFC,0x86,0x98,0xDF,0x7F,0x5C,0xD5,0x00,0x28,0x64,0x9F,0x85,0x39,0x91,0xE3,0xFB,0x54,0x5F,0x4D,0xDB,0x7B,0xB8};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x7E,0x07,0x00,0x2A,0xAF,0xFE,0x11,0x1A,0x0D,0x62,0xFF,0x76,0x14,0x63,0x80,0x66,0x50,0x7E,0xE4,0x06,0x2D,0x17,0x43,0x02,0xBD,0xEC,0x73,0x58,0x2E,0x5B,0x2D,0x6E};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^203)*G
			{
				const static sl_uint8 _x[] = {0xB0,0xF9,0xE4,0xB9,0xB2,0x97,0x90,0xB6,0x33,0xBC,0xC0,0x4F,0xD8,0x60,0xCB,0x0F,0x82,0x3D,0x8D,0x1A,0x4C,0xC1,0xA1,0xC1,0x41,0x3C,0x16,0x06,0xCC,0x9A,0x8E,0x2C};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x49,0xE8,0x2B,0xF1,0x84,0x3A,0xDE,0x6D,0x41,0xCB,0xB0,0xB9,0x06,0xFD,0xE3,0xF0,0x33,0x50,0xCC,0x02,0xC1,0x71,0xCE,0xE7,0x6C,0x20,0x66,0xC4,0xDF,0x3D,0x0D,0xB4};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^204)*G
			{
				const static sl_uint8 _x[] = {0x14,0x6A,0x77,0x8C,0x04,0x67,0x0C,0x2F,0x91,0xB0,0x0A,0xF4,0x68,0x0D,0xFA,0x8B,0xCE,0x34,0x90,0x71,0x7D,0x58,0xBA,0x88,0x9D,0xDB,0x59,0x28,0x36,0x66,0x42,0xBE};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xB3,0x18,0xE0,0xEC,0x33,0x54,0x02,0x8A,0xDD,0x66,0x98,0x27,0xF9,0xD4,0xB2,0x87,0x0A,0xAA,0x97,0x1D,0x2F,0x7E,0x5E,0xD1,0xD0,0xB2,0x97,0x48,0x3D,0x83,0xEF,0xD0};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^205)*G
			{
				const static sl_uint8 _x[] = {0x57,0x4E,0xF0,0xCE,0x8A,0x59,0x7E,0x24,0xE5,0x67,0x0B,0x5C,0x0B,0xCD,0x14,0xCF,0xEE,0xFC,0x98,0x3C,0x7E,0xCB,0x26,0x19,0x11,0xB2,0x36,0x55,0x79,0xDE,0x5C,0xAC};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x09,0xB9,0x99,0x30,0x28,0x1F,0x19,0xC7,0x3B,0xD6,0xAD,0xA0,0x56,0x9B,0x78,0x45,0x1A,0x26,0x0A,0x7B,0xEF,0x10,0x00,0x8C,0xAE,0x59,0xAE,0xA6,0xC7,0x5A,0x48,0x05};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^206)*G
			{
				const static sl_uint8 _x[] = {0xD3,0xD9,0x7E,0x79,0x9D,0x8B,0xF9,0xF8,0x5D,0x90,0x93,0x97,0xB9,0x8C,0x83,0x5D,0x10,0xA7,0x70,0xC1,0xAE,0xFF,0x86,0x45,0x80,0x8C,0x2D,0x74,0x26,0x09,0x66,0xD3};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x8D,0xDB,0xB4,0x63,0x76,0xBA,0xC9,0x5E,0x6A,0xAA,0x89,0x27,0x5D,0x40,0x3A,0xD3,0xB5,0xE4,0x87,0x11,0xBE,0x8D,0xC4,0xEE,0xBD,0xDE,0xB8,0x50,0x83,0x3C,0x2E,0x52};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^207)*G
			{
				const static sl_uint8 _x[] = {0xB1,0xAA,0x65,0x32,0x88,0xB3,0x18,0x98,0x7B,0x97,0x4E,0x78,0x2C,0xBB,0xEE,0x0A,0xB2,0xBE,0x78,0xCF,0x8F,0x49,0x4C,0x12,0x00,0x40,0xFB,0x93,0x96,0x8C,0x6D,0x4B};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x7E,0xD6,0x07,0x1C,0x60,0x81,0x0D,0x71,0x26,0x84,0xAA,0x8E,0x2D,0x63,0xA8,0x3B,0x10,0x0A,0x1D,0x90,0x9D,0x62,0x3C,0xC3,0x83,0xD9,0xE6,0x2A,0xE8,0x91,0xAC,0x51};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^208)*G
			{
				const static sl_uint8 _x[] = {0xFA,0x50,0xC0,0xF6,0x1D,0x22,0xE5,0xF0,0x7E,0x3A,0xCE,0xBB,0x1A,0xA0,0x7B,0x12,0x8D,0x00,0x12,0x20,0x9A,0x28,0xB9,0x77,0x6D,0x76,0xA8,0x79,0x31,0x80,0xEE,0xF9};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x6B,0x84,0xC6,0x92,0x23,0x97,0xEB,0xA9,0xB7,0x2C,0xD2,0x87,0x22,0x81,0xA6,0x8A,0x5E,0x68,0x32,0x93,0xA5,0x7A,0x21,0x3B,0x38,0xCD,0x8D,0x7D,0x3F,0x4F,0x28,0x11};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^209)*G
			{
				const static sl_uint8 _x[] = {0x63,0x96,0x4E,0xEE,0x61,0x90,0x74,0xE0,0x78,0x01,0x40,0xFE,0x02,0xE9,0x08,0x36,0xE7,0x23,0x28,0xD2,0x44,0x83,0x86,0xD4,0x59,0xC5,0xBE,0x23,0x18,0x7F,0x50,0x48};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x3B,0x6C,0xFB,0x3A,0x6B,0x89,0xCF,0x41,0xA3,0x9F,0xF9,0xB1,0xC3,0x4B,0xFB,0xC9,0x3D,0x58,0x0B,0x93,0x4D,0xDE,0x6C,0x84,0x38,0x3A,0x28,0x4D,0x89,0x30,0x9D,0xF8};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^210)*G
			{
				const static sl_uint8 _x[] = {0x5A,0x3C,0xE2,0x5B,0x4D,0x15,0xB7,0xE2,0x2D,0x14,0x69,0xDD,0xF0,0xFC,0x9F,0x75,0xAF,0xD7,0xF1,0x2A,0xD3,0xCB,0xDA,0x31,0xF8,0x14,0xBA,0x1E,0xBA,0xDB,0x2A,0x65};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x8B,0x34,0x12,0x5B,0x92,0xE0,0x5F,0x63,0x87,0x3A,0x6D,0xBF,0xBF,0x3F,0x99,0xAF,0x3E,0xE2,0x8B,0xC3,0xD8,0x25,0xFE,0x8E,0xD8,0xB1,0x70,0xCF,0x1D,0x32,0x7F,0x1D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^211)*G
			{
				const static sl_uint8 _x[] = {0x5C,0xE6,0x05,0xAF,0x98,0xF9,0x3E,0xDA,0x69,0x10,0xBE,0x34,0xF0,0xDE,0x41,0xFF,0x85,0xDB,0xCB,0x6E,0x69,0xA8,0xFA,0x00,0x16,0xA7,0x33,0x75,0x4A,0x9F,0x44,0xD0};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x4C,0xDD,0xCF,0x9B,0xEC,0x22,0x6B,0xFE,0x7B,0xA5,0x6B,0xD0,0x31,0xC7,0x6C,0x58,0xAB,0x3C,0xB1,0xBF,0xA3,0x2E,0xCC,0xC6,0xC0,0xD0,0x5F,0x34,0x89,0xD3,0x01,0x05};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^212)*G
			{
				const static sl_uint8 _x[] = {0xDA,0x1D,0x61,0xD0,0xCA,0x72,0x1A,0x11,0xB1,0xA5,0xBF,0x6B,0x7D,0x88,0xE8,0x42,0x1A,0x28,0x8A,0xB5,0xD5,0xBB,0xA5,0x22,0x0E,0x53,0xD3,0x2B,0x5F,0x06,0x7E,0xC2};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x81,0x57,0xF5,0x5A,0x7C,0x99,0x30,0x6C,0x79,0xC0,0x76,0x61,0x61,0xC9,0x1E,0x29,0x66,0xA7,0x38,0x99,0xD2,0x79,0xB4,0x8A,0x65,0x5F,0xBA,0x0F,0x1A,0xD8,0x36,0xF1};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^213)*G
			{
				const static sl_uint8 _x[] = {0x9C,0x7B,0xE0,0x0B,0x4E,0xF4,0xC4,0x44,0xDF,0x85,0xD5,0xF6,0x1D,0xC1,0x28,0x3A,0x23,0x60,0x54,0x83,0xE1,0xF8,0xE9,0x34,0xB3,0xC2,0x10,0xD2,0x2C,0xD3,0xC3,0x69};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x92,0x20,0xC0,0xDE,0x74,0xB2,0x0D,0x20,0x52,0xA2,0x6D,0x45,0x5C,0xE4,0x01,0x48,0x3E,0x31,0x15,0x3A,0x16,0x76,0x9C,0xBD,0x29,0xEE,0x3F,0xEB,0xA2,0x32,0x95,0x15};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^214)*G
			{
				const static sl_uint8 _x[] = {0x0F,0xCD,0x83,0xF4,0x28,0x25,0x26,0x3B,0xB5,0x56,0x64,0xB2,0x38,0xCC,0xC4,0x91,0x74,0xDD,0x06,0xA7,0x05,0x41,0x17,0x8E,0x76,0xBC,0xD9,0x2D,0x7B,0xB8,0xC9,0xE3};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x6C,0x0B,0xC1,0xCF,0xEA,0xC5,0xFB,0xCE,0xD1,0xD8,0x23,0x2D,0xE5,0xFD,0xB6,0x83,0xAD,0xBE,0xAE,0xCD,0xF1,0x62,0x7B,0xF4,0xE8,0x6D,0x55,0xFB,0xDF,0x4A,0xA9,0xAD};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^215)*G
			{
				const static sl_uint8 _x[] = {0x71,0x75,0x40,0x7F,0x1B,0x58,0xF0,0x10,0xD4,0xCD,0xA4,0xC6,0x25,0x11,0xE5,0x9D,0xB7,0xED,0xCF,0x28,0xF5,0x47,0x6D,0x99,0x5C,0xF3,0x99,0x44,0xB2,0x6B,0x64,0xF1};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x43,0xB4,0x55,0x43,0x44,0xE3,0xD5,0x50,0xF3,0x6D,0x34,0x01,0x13,0x4C,0xC8,0x6E,0xB0,0x1F,0xE8,0xB7,0x74,0x47,0x1D,0x2A,0x42,0x6E,0x7E,0xFA,0xB2,0x42,0x34,0xD5};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^216)*G
			{
				const static sl_uint8 _x[] = {0xA8,0xE2,0x82,0xFF,0x0C,0x97,0x06,0x90,0x72,0x15,0xFF,0x98,0xE8,0xFD,0x41,0x66,0x15,0x31,0x1D,0xE0,0x44,0x6F,0x1E,0x06,0x2A,0x73,0xB0,0x61,0x0D,0x06,0x4E,0x13};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x7F,0x97,0x35,0x5B,0x8D,0xB8,0x1C,0x09,0xAB,0xFB,0x7F,0x3C,0x5B,0x25,0x15,0x88,0x8B,0x67,0x9A,0x3E,0x50,0xDD,0x6B,0xD6,0xCE,0xF7,0xC7,0x31,0x11,0xF4,0xCC,0x0C};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^217)*G
			{
				const static sl_uint8 _x[] = {0xCA,0xC6,0xF2,0xE7,0xE2,0x7F,0xAE,0xCB,0xCB,0x87,0x6F,0x80,0x5E,0xA6,0x6E,0x63,0xEF,0xBE,0x9E,0xAA,0x75,0x3D,0x67,0xC1,0xC1,0x5E,0xB9,0xEA,0x7F,0x76,0x53,0xA1};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xF7,0xD4,0x16,0xE5,0xE2,0xAA,0x6F,0x19,0x4C,0xDB,0x65,0xD9,0xA4,0x2A,0x34,0x50,0x81,0xE8,0x3A,0xE5,0x68,0x81,0x03,0xA0,0x68,0xC1,0x0A,0xD0,0xFE,0xC5,0xE5,0x56};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^218)*G
			{
				const static sl_uint8 _x[] = {0xE6,0xDF,0xDE,0x46,0xEE,0x37,0xD2,0x06,0xEF,0xBC,0x59,0x32,0xE5,0x8E,0x43,0x25,0x4A,0xB7,0x67,0x29,0x42,0x38,0xCB,0x11,0xCC,0x9F,0x4A,0xB0,0x86,0x24,0x00,0x3D};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x87,0x27,0xB3,0xB7,0xBE,0x91,0x39,0x49,0x8F,0x2F,0x48,0xF7,0xB8,0x8F,0x92,0x20,0x3B,0x1C,0xE5,0xEA,0x52,0x7F,0xD7,0xDD,0x75,0x48,0x65,0x0E,0x22,0x16,0xB9,0x3B};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^219)*G
			{
				const static sl_uint8 _x[] = {0x3C,0x4E,0x08,0x9C,0xD9,0xA6,0x82,0x3D,0x66,0xA4,0x0C,0xFC,0x7A,0xC9,0x60,0x82,0xE2,0x50,0xE3,0x14,0x9C,0xF2,0x11,0xD3,0xB0,0xE1,0x10,0x35,0x48,0xDC,0xE1,0x09};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x43,0xFB,0xBE,0x66,0x9F,0xE1,0x91,0xB4,0x80,0x75,0x7B,0xCA,0x15,0x76,0x4D,0x37,0x95,0x79,0xE1,0x42,0xD9,0x7F,0xE6,0x97,0xE2,0xBF,0x65,0x92,0x3A,0x19,0xAE,0xEA};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^220)*G
			{
				const static sl_uint8 _x[] = {0x17,0x4A,0x53,0xB9,0xC9,0xA2,0x85,0x87,0x2D,0x39,0xE5,0x6E,0x69,0x13,0xCA,0xB1,0x5D,0x59,0xB1,0xFA,0x51,0x25,0x08,0xC0,0x22,0xF3,0x82,0xDE,0x83,0x19,0x49,0x7C};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xCC,0xC9,0xDC,0x37,0xAB,0xFC,0x9C,0x16,0x57,0xB4,0x15,0x5F,0x2C,0x47,0xF9,0xE6,0x64,0x6B,0x3A,0x1D,0x8C,0xB9,0x85,0x43,0x83,0xDA,0x13,0xAC,0x07,0x9A,0xFA,0x73};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^221)*G
			{
				const static sl_uint8 _x[] = {0x20,0xE6,0xE2,0xE7,0x96,0x94,0x6B,0xB6,0x30,0xC7,0x07,0x1E,0xF1,0xB9,0x2E,0xA3,0xD5,0x3D,0x28,0x0E,0x0E,0x45,0x01,0x11,0x5F,0x5D,0xA3,0x6F,0x84,0x0D,0xD2,0x73};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xD3,0xAD,0x7A,0xFE,0x4F,0x15,0x59,0xE4,0x4A,0x0B,0xA1,0xAD,0x97,0x87,0x46,0x55,0x81,0x1E,0xC9,0x79,0x3D,0xA8,0x69,0x3C,0xC0,0x7C,0xFD,0x15,0xBB,0x46,0xB5,0x93};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^222)*G
			{
				const static sl_uint8 _x[] = {0x8E,0x0C,0xA8,0x24,0xD7,0xA3,0x51,0xDB,0xA8,0x02,0x80,0xA0,0x7E,0x71,0xDB,0x70,0x35,0xAE,0x68,0x13,0x6C,0xC2,0x4C,0xA3,0xE7,0xB5,0x4F,0x30,0x1A,0x07,0x76,0x74};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x04,0xEC,0x56,0x07,0x59,0x19,0x2D,0x41,0xDC,0x56,0x9D,0x24,0xDA,0x62,0xCF,0x57,0xCF,0xF6,0x04,0x19,0xD2,0xF9,0x10,0x29,0x0B,0x84,0xCB,0xEC,0x12,0xB7,0xED,0x98};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^223)*G
			{
				const static sl_uint8 _x[] = {0xF7,0xBB,0x50,0xDA,0x51,0xC9,0x82,0xD1,0xC5,0xFA,0x63,0x55,0x3E,0x3D,0x66,0xC1,0xAF,0xDB,0x58,0x21,0xA3,0x21,0xB4,0xAF,0xE9,0x6A,0xFC,0x5E,0xA8,0x19,0x24,0x41};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x93,0xCC,0x3B,0xE3,0x03,0x34,0xA5,0x26,0x31,0x1B,0xC6,0x3B,0xDD,0xE6,0x48,0x5D,0xB1,0xCF,0xDC,0x1F,0xBB,0xC4,0xC7,0x4B,0xBC,0x64,0x0E,0xA1,0xD4,0x51,0x65,0xAE};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^224)*G
			{
				const static sl_uint8 _x[] = {0x95,0x93,0x96,0x98,0x19,0x43,0x78,0x5C,0x3D,0x3E,0x57,0xED,0xF5,0x01,0x8C,0xDB,0xE0,0x39,0xE7,0x30,0xE4,0x91,0x8B,0x3D,0x88,0x4F,0xDF,0xF0,0x94,0x75,0xB7,0xBA};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x2E,0x7E,0x55,0x28,0x88,0xC3,0x31,0xDD,0x8B,0xA0,0x38,0x6A,0x4B,0x9C,0xD6,0x84,0x9C,0x65,0x3F,0x64,0xC8,0x70,0x93,0x85,0xE9,0xB8,0xAB,0xF8,0x75,0x24,0xF2,0xFD};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^225)*G
			{
				const static sl_uint8 _x[] = {0xCB,0xEE,0x14,0x05,0xFF,0x0D,0xA7,0xDE,0xAF,0xE3,0x2C,0xA7,0xDD,0x73,0xD9,0x5E,0xD7,0x02,0x22,0x6B,0x39,0x17,0x47,0xC7,0x07,0x27,0x5A,0x94,0x0B,0xC8,0xF5,0x3B};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xF6,0x21,0x1F,0x4F,0x4E,0x75,0xF9,0x02,0xB5,0x1F,0x3E,0x68,0x9B,0x82,0x94,0xCF,0x0D,0x9F,0xF4,0xF6,0x81,0x26,0xF7,0x28,0x29,0x22,0xE6,0xB2,0x78,0xC8,0x7F,0x45};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^226)*G
			{
				const static sl_uint8 _x[] = {0xAD,0xD5,0xBA,0xD2,0x8F,0xAA,0xF5,0xAC,0xDD,0x58,0x0B,0xFA,0x0B,0xA2,0x52,0xE0,0x3D,0xE3,0xBE,0xAE,0xFB,0xD7,0x1B,0x9C,0xF3,0x77,0xC8,0x8B,0x14,0xB3,0x11,0xDD};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xE9,0xC4,0x3C,0xF4,0xDA,0x3D,0xC3,0xA5,0x97,0x4E,0x43,0x4F,0x83,0x59,0x81,0x4F,0x52,0xD4,0xE1,0xE7,0x66,0x9B,0x9B,0x89,0x02,0xF9,0x82,0xF3,0x49,0xD6,0xC3,0x8D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^227)*G
			{
				const static sl_uint8 _x[] = {0x53,0xF2,0x43,0x2B,0xA8,0x17,0x17,0x14,0x3F,0xA9,0xDF,0x3D,0xFF,0x41,0xCE,0xD2,0x4A,0x29,0xB3,0x14,0xBC,0x5A,0x8C,0x96,0xF5,0xF6,0x40,0x0A,0x0D,0x7C,0x09,0x79};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xBD,0x52,0xEF,0xFB,0xC1,0xF0,0x79,0xB7,0xCC,0xD4,0xE3,0xE0,0x91,0x1B,0x07,0xDE,0x4B,0xD5,0xA4,0xF5,0xC9,0xE8,0xB8,0x45,0xF9,0xF7,0xE9,0x0C,0x53,0x7B,0x36,0xA2};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^228)*G
			{
				const static sl_uint8 _x[] = {0xD2,0xA6,0x3A,0x50,0xAE,0x40,0x1E,0x56,0xD6,0x45,0xA1,0x15,0x3B,0x10,0x9A,0x8F,0xCC,0xA0,0xA4,0x3D,0x56,0x1F,0xBA,0x2D,0xBB,0x51,0x34,0x0C,0x9D,0x82,0xB1,0x51};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xE8,0x2D,0x86,0xFB,0x64,0x43,0xFC,0xB7,0x56,0x5A,0xEE,0x58,0xB2,0x94,0x82,0x20,0xA7,0x0F,0x75,0x0A,0xF4,0x84,0xCA,0x52,0xD4,0x14,0x21,0x74,0xDC,0xF8,0x94,0x05};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^229)*G
			{
				const static sl_uint8 _x[] = {0xBA,0xF1,0x83,0xA7,0x61,0x00,0x52,0x5E,0x23,0xBC,0x72,0x02,0x03,0x37,0x25,0xF9,0x22,0xB9,0xCD,0x6B,0x36,0xC4,0x13,0x49,0x7C,0x6C,0x4B,0xAC,0xCA,0x72,0xDA,0x5F};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xDE,0xAC,0x9F,0xBE,0x9C,0xCB,0x4D,0x33,0x56,0x88,0xBD,0x58,0xDD,0x69,0xB1,0xD1,0x8E,0x23,0x36,0xC5,0xCA,0x73,0x93,0x61,0x37,0x7C,0xE6,0x28,0xA8,0xF2,0xA0,0xCF};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^230)*G
			{
				const static sl_uint8 _x[] = {0xF7,0xAE,0xF8,0xA7,0xE3,0x84,0x40,0x23,0x8F,0x93,0x32,0x90,0x6E,0x48,0xF6,0xFD,0x5A,0xDB,0xD0,0x2D,0x56,0xB7,0x6A,0x5F,0xFA,0x5A,0xCA,0x58,0xC5,0x6C,0x39,0x43};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x4E,0x3B,0x0B,0x44,0xD5,0xFF,0xDA,0x79,0x7C,0x44,0x2B,0xBD,0xC3,0xAB,0x3F,0xCF,0xEE,0xC3,0x01,0x84,0xA8,0xDC,0xD0,0x03,0x43,0x1F,0x62,0x7F,0xAC,0xF4,0x42,0xF1};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^231)*G
			{
				const static sl_uint8 _x[] = {0xDF,0xB5,0x47,0xCB,0x10,0x01,0x90,0x36,0xC5,0xA2,0xE2,0x9F,0x0D,0xDD,0xBB,0x1F,0x7A,0xF2,0xFA,0x25,0xA3,0xC7,0xA7,0x8C,0x1F,0xAC,0x94,0x57,0x11,0x92,0x44,0x59};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x9A,0xCC,0xD2,0xA9,0xBA,0x0F,0x47,0x08,0x8B,0x83,0x89,0xCE,0x9D,0xC8,0x64,0xCC,0x22,0xAF,0x09,0x30,0xE5,0xC0,0x31,0xDC,0xFA,0x20,0x5E,0x0D,0xCC,0x65,0xFD,0x9E};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^232)*G
			{
				const static sl_uint8 _x[] = {0x64,0x58,0x7E,0x23,0x35,0x47,0x1E,0xB8,0x90,0xEE,0x78,0x96,0xD7,0xCF,0xDC,0x86,0x6B,0xAC,0xBD,0xBD,0x38,0x39,0x31,0x7B,0x34,0x36,0xF9,0xB4,0x56,0x17,0xE0,0x73};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xD9,0x9F,0xCD,0xD5,0xBF,0x69,0x02,0xE2,0xAE,0x96,0xDD,0x64,0x47,0xC2,0x99,0xA1,0x85,0xB9,0x0A,0x39,0x13,0x3A,0xEA,0xB3,0x58,0x29,0x9E,0x5E,0x9F,0xAF,0x65,0x89};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^233)*G
			{
				const static sl_uint8 _x[] = {0xB8,0x66,0xD6,0xB1,0x42,0xDF,0x94,0x0F,0x2C,0xF2,0x8B,0x54,0xC9,0x2F,0x0C,0x12,0x94,0xE0,0xB6,0xA2,0x2A,0x91,0xF2,0xEF,0x44,0xBC,0xD8,0x8C,0x43,0x84,0x48,0x0D};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x19,0x14,0xB0,0xB3,0x42,0x6A,0xEB,0x70,0x89,0xA2,0x78,0xD7,0xEA,0x9A,0xD7,0xAC,0x24,0xE5,0x22,0x80,0x4B,0x1D,0x86,0xD6,0x0E,0x65,0x9B,0x47,0x0C,0x4C,0xAF,0xA8};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^234)*G
			{
				const static sl_uint8 _x[] = {0xEC,0x2B,0xB8,0x90,0x85,0xDE,0x81,0x9E,0xC4,0xD9,0xD1,0x64,0x61,0x02,0xBA,0x87,0xE2,0xD5,0x2A,0xE4,0xED,0x4F,0xE4,0x55,0xD2,0x29,0xCD,0xA8,0x1D,0xB2,0x0D,0x6C};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xCC,0xEC,0xC1,0x76,0x61,0xE0,0x13,0xA1,0x33,0x2F,0x66,0xF0,0x65,0x09,0x40,0xC6,0x33,0xA2,0x36,0x4B,0xE8,0x7E,0xFA,0x98,0xA0,0xE9,0x9C,0x4D,0x62,0x9C,0xF4,0xA0};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^235)*G
			{
				const static sl_uint8 _x[] = {0x71,0xC4,0xA7,0xE3,0x89,0xE2,0x96,0xCE,0xD3,0x9D,0x75,0xEF,0x5E,0x54,0x59,0x05,0xE5,0x00,0x50,0x64,0x0F,0x50,0xBE,0xCF,0x38,0xA6,0x0E,0xCB,0x23,0xB0,0x9D,0x0F};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x13,0x13,0xFA,0xDB,0x73,0x7A,0xF3,0xBA,0x0A,0xF3,0xE0,0xA2,0x92,0xF8,0x10,0xAA,0x78,0x6F,0x2B,0x08,0x4A,0x62,0xFF,0xC7,0x63,0x7B,0x1F,0x01,0x72,0x0D,0xDB,0x62};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^236)*G
			{
				const static sl_uint8 _x[] = {0x84,0x81,0xBD,0xE0,0xE4,0xE4,0xD8,0x85,0xB3,0xA5,0x46,0xD3,0xE5,0x49,0xDE,0x04,0x2F,0x0A,0xA6,0xCE,0xA2,0x50,0xE7,0xFD,0x35,0x8D,0x6C,0x86,0xDD,0x45,0xE4,0x58};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x38,0xEE,0x7B,0x8C,0xBA,0x54,0x04,0xDD,0x84,0xA2,0x5B,0xF3,0x9C,0xEC,0xB2,0xCA,0x90,0x0A,0x79,0xC4,0x2B,0x26,0x2E,0x55,0x6D,0x64,0xB1,0xB5,0x97,0x79,0x05,0x7E};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^237)*G
			{
				const static sl_uint8 _x[] = {0x96,0x29,0xA4,0x50,0xBD,0x38,0x3A,0x8B,0x9F,0xD4,0x3C,0x6C,0xD1,0xD4,0x92,0xBF,0x39,0x2E,0xD6,0x05,0x29,0x95,0x61,0xDD,0xE5,0x44,0x33,0x52,0x6C,0xE9,0xF1,0x14};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xBF,0x43,0x9B,0x28,0x0C,0x5F,0xB6,0xD7,0x57,0x6B,0xEF,0xD2,0x20,0xCE,0xF6,0x4D,0xB9,0x25,0x59,0x3E,0x5C,0x56,0xAF,0x8D,0xCA,0x39,0x72,0xC4,0xA2,0x4A,0xA3,0x91};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^238)*G
			{
				const static sl_uint8 _x[] = {0xB7,0x3B,0x1C,0x47,0xEF,0x1E,0x46,0x88,0xEB,0x17,0x30,0xDA,0x7C,0xC8,0x93,0xDF,0x14,0x77,0xD7,0x47,0xE1,0x87,0xE1,0x83,0x83,0xD3,0x8D,0x96,0x26,0xCA,0x6C,0xC3};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x58,0x43,0x15,0xCB,0x29,0x49,0x22,0xA9,0x0A,0x57,0xD6,0x4B,0xBC,0xC8,0x05,0x09,0x73,0x22,0xA2,0x52,0x09,0x75,0x7F,0x5A,0xFA,0xC3,0x5D,0x76,0xA5,0x4F,0xDB,0xA3};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^239)*G
			{
				const static sl_uint8 _x[] = {0xED,0xFE,0x16,0xB2,0xDB,0x40,0x18,0x03,0x11,0xF9,0x89,0x20,0x07,0xA2,0xFE,0xF7,0xD0,0x5B,0x2A,0x3B,0xB6,0x76,0x89,0x9F,0x9C,0x6E,0x21,0x92,0xD3,0x8F,0x93,0xE0};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xEE,0x69,0x02,0xF1,0xFC,0xA5,0xDB,0x36,0x94,0xD7,0x4F,0xAA,0x4B,0x05,0xD0,0xD2,0x5B,0x3D,0x51,0x00,0xC4,0x6E,0x22,0x7E,0x3D,0x01,0x79,0x3D,0xE2,0x94,0x05,0xAD};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^240)*G
			{
				const static sl_uint8 _x[] = {0x13,0x46,0x4A,0x57,0xA7,0x81,0x02,0xAA,0x62,0xB6,0x97,0x9A,0xE8,0x17,0xF4,0x63,0x7F,0xFC,0xFE,0xD3,0xC4,0xB1,0xCE,0x30,0xBC,0xD6,0x30,0x3F,0x6C,0xAF,0x66,0x6B};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x69,0xBE,0x15,0x90,0x04,0x61,0x45,0x80,0xEF,0x7E,0x43,0x34,0x53,0xCC,0xB0,0xCA,0x48,0xF3,0x00,0xA8,0x1D,0x09,0x42,0xE1,0x3F,0x49,0x5A,0x90,0x7F,0x6E,0xCC,0x27};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^241)*G
			{
				const static sl_uint8 _x[] = {0xEB,0x3C,0xF8,0xF5,0x32,0x24,0x53,0x62,0xEC,0x05,0xC8,0x8C,0x85,0xFE,0x12,0xD1,0x91,0x82,0xBE,0x7D,0xCE,0xAB,0xE5,0x77,0xC7,0x58,0x49,0xC6,0x06,0x50,0x84,0xAE};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xC8,0x33,0xC7,0x82,0x22,0xD9,0xD7,0x00,0x43,0xFE,0x63,0xDC,0xEF,0xDC,0xA4,0xA1,0xF5,0x2B,0x45,0xC5,0xE7,0xDB,0xD2,0xA6,0x6F,0x67,0xC1,0xFF,0xF9,0x6B,0x94,0x80};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^242)*G
			{
				const static sl_uint8 _x[] = {0xBD,0xF1,0xA6,0x7D,0x09,0x2D,0x99,0x97,0x4F,0x7A,0x60,0xF2,0x18,0x45,0x19,0xB2,0xA5,0x76,0xFC,0xF9,0x84,0xA2,0x01,0xD9,0xF8,0xE5,0xBC,0xBC,0xC2,0xE9,0xA5,0xD0};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x40,0x95,0x90,0x2B,0xAB,0x65,0xA1,0xAA,0xA8,0x0B,0xE5,0x4A,0x86,0xBF,0x7B,0xAA,0xA6,0x28,0x0B,0x61,0xE5,0x62,0x64,0x61,0xCD,0xB4,0xF7,0x01,0x85,0x62,0xFF,0x7B};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^243)*G
			{
				const static sl_uint8 _x[] = {0x68,0x85,0x6A,0x6E,0xDD,0xC4,0xEC,0x29,0xCD,0x5B,0xE2,0x67,0xB6,0x44,0x83,0xB4,0x8C,0x3B,0x41,0x96,0x47,0x7D,0xA6,0x2A,0xBD,0xE5,0xFC,0x17,0x3B,0x27,0xE7,0x71};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x77,0xA3,0x3D,0xF1,0x4F,0x79,0xA1,0xFB,0x13,0xB6,0xFD,0x49,0xC1,0x9F,0x7B,0x4A,0x33,0x1D,0x22,0xF2,0x93,0xB0,0x73,0x3A,0x61,0x18,0xD6,0x2A,0x07,0xBB,0xDA,0xB6};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^244)*G
			{
				const static sl_uint8 _x[] = {0xBC,0x4A,0x9D,0xF5,0xB7,0x13,0xFE,0x2E,0x9A,0xEF,0x43,0x0B,0xCC,0x1D,0xC9,0x7A,0x0C,0xD9,0xCC,0xED,0xE2,0xF2,0x85,0x88,0xCA,0xDA,0x3A,0x0D,0x2D,0x83,0xF3,0x66};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x0D,0x3A,0x81,0xCA,0x6E,0x78,0x5C,0x06,0x38,0x39,0x37,0xAD,0xF4,0xB7,0x98,0xCA,0xA6,0xE8,0xA9,0xFB,0xFA,0x54,0x7B,0x16,0xD7,0x58,0xD6,0x66,0x58,0x1F,0x33,0xC1};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^245)*G
			{
				const static sl_uint8 _x[] = {0xDA,0x43,0x3D,0x5E,0x11,0xCE,0xCC,0xC0,0xAB,0xC5,0xC7,0x62,0x6C,0xE7,0xBA,0xB4,0x2E,0x89,0xB2,0x21,0xF7,0x85,0xC4,0x09,0x28,0x2D,0xE5,0x45,0xF3,0xFC,0xEB,0x19};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xE4,0x98,0xDB,0xD3,0x21,0xA8,0x10,0x30,0x1D,0xEB,0xBD,0xC4,0xAF,0x95,0xE5,0x21,0x8E,0x77,0xFC,0x2D,0x92,0x27,0xB2,0x77,0x68,0x4E,0x71,0x20,0xA6,0xF5,0xCC,0x64};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^246)*G
			{
				const static sl_uint8 _x[] = {0x03,0x1E,0x8E,0x1E,0xE9,0xE8,0xC7,0xEC,0x1C,0x1C,0x11,0x69,0x81,0xC1,0x6E,0xFD,0xBC,0xC4,0x83,0x8A,0x72,0x20,0x7E,0x06,0x54,0xDE,0x27,0x5C,0x5A,0xCF,0x69,0x2A};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xAD,0x7E,0x7F,0x5B,0x46,0x5B,0x35,0x3D,0xD9,0xD0,0x97,0x02,0x90,0xD6,0x74,0x3B,0x70,0x64,0x98,0x27,0xC5,0xBF,0x73,0xB0,0x9C,0xC2,0xA8,0x4E,0xB1,0x6F,0x66,0x7A};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^247)*G
			{
				const static sl_uint8 _x[] = {0xA9,0x87,0x86,0x07,0xA8,0x8D,0x61,0x15,0x5D,0x3E,0x00,0xD8,0x62,0x65,0x7F,0x73,0xE9,0xC9,0xBF,0x36,0x3F,0xC7,0xA9,0x15,0x92,0xBB,0xD7,0xFF,0x81,0xF4,0x88,0xB6};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xD1,0x81,0xA1,0xAB,0xD5,0x88,0x95,0xD6,0x1C,0x06,0x3E,0x7C,0x82,0x15,0x7C,0x22,0x39,0xD0,0xF0,0x19,0x64,0xAD,0x5C,0x6D,0x49,0x5A,0x7B,0xBB,0x03,0x1D,0xAB,0x1D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^248)*G
			{
				const static sl_uint8 _x[] = {0x8C,0x28,0xA9,0x7B,0xF8,0x29,0x8B,0xC0,0xD2,0x3D,0x8C,0x74,0x94,0x52,0xA3,0x2E,0x69,0x4B,0x65,0xE3,0x0A,0x94,0x72,0xA3,0x95,0x4A,0xB3,0x0F,0xE5,0x32,0x4C,0xAA};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x40,0xA3,0x04,0x63,0xA3,0x30,0x51,0x93,0x37,0x8F,0xED,0xF3,0x1F,0x7C,0xC0,0xEB,0x7A,0xE7,0x84,0xF0,0x45,0x1C,0xB9,0x45,0x9E,0x71,0xDC,0x73,0xCB,0xEF,0x94,0x82};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^249)*G
			{
				const static sl_uint8 _x[] = {0xAB,0x1A,0xC1,0x87,0x2A,0x38,0xA2,0xF1,0x96,0xBE,0xD5,0xA6,0x04,0x7F,0x0D,0xA2,0xC8,0x13,0x0F,0xE8,0xDE,0x49,0xFC,0x4D,0x5D,0xFB,0x20,0x1F,0x76,0x11,0xD8,0xE2};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x13,0xF4,0xA3,0x7A,0x32,0x4D,0x17,0xA1,0xE9,0xAA,0x5F,0x39,0xDB,0x6A,0x42,0xB6,0xF7,0xEF,0x93,0xD3,0x3E,0x1E,0x54,0x5F,0x01,0xA5,0x81,0xF3,0xC4,0x29,0xD1,0x5B};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^250)*G
			{
				const static sl_uint8 _x[] = {0x25,0x64,0xFE,0x9B,0x5B,0xEE,0xF8,0x2D,0x37,0x03,0xA6,0x07,0x25,0x3F,0x31,0xEF,0x8E,0xA1,0xB3,0x65,0x77,0x2D,0xF4,0x34,0x22,0x6A,0xEE,0x64,0x26,0x51,0xB3,0xFA};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x8A,0xD9,0xF7,0xA6,0x06,0x78,0x38,0x90,0x95,0xFA,0x14,0xAE,0x12,0x03,0x92,0x5F,0x14,0xF3,0x7D,0xAB,0x6B,0x79,0x81,0x6E,0xDB,0x82,0xE6,0xA3,0x01,0xE5,0x12,0x2D};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^251)*G
			{
				const static sl_uint8 _x[] = {0xFF,0x3D,0x61,0x36,0xFF,0xAC,0x5B,0x0C,0xBF,0xC6,0xC5,0xC0,0xC3,0x0D,0xC0,0x1A,0x7E,0xA3,0xD5,0x6C,0x20,0xBD,0x31,0x03,0xB1,0x78,0xE3,0xD3,0xAE,0x18,0x00,0x68};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x13,0x32,0x39,0xBE,0x84,0xE4,0x00,0x0E,0x40,0xD0,0x37,0x2C,0xDD,0x96,0xAD,0xC1,0x54,0x76,0x76,0xF2,0x40,0x01,0xF5,0xE6,0x70,0xA6,0xBB,0x6E,0x18,0x8C,0x60,0x77};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^252)*G
			{
				const static sl_uint8 _x[] = {0x08,0xEA,0x96,0x66,0x13,0x95,0x27,0xA8,0xC1,0xDD,0x94,0xCE,0x4F,0x07,0x1F,0xD2,0x3C,0x8B,0x35,0x0C,0x5A,0x4B,0xB3,0x37,0x48,0xC4,0xBA,0x11,0x1F,0xAC,0xCA,0xE0};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x62,0x0E,0xFA,0xBB,0xC8,0xEE,0x27,0x82,0xE2,0x4E,0x7C,0x0C,0xFB,0x95,0xC5,0xD7,0x35,0xB7,0x83,0xBE,0x9C,0xF0,0xF8,0xE9,0x55,0xAF,0x34,0xA3,0x0E,0x62,0xB9,0x45};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^253)*G
			{
				const static sl_uint8 _x[] = {0xC2,0x5F,0x63,0x71,0x76,0x22,0x0C,0xD9,0xF3,0xA6,0x6D,0xF3,0x15,0x55,0x9D,0x82,0x63,0xCF,0x2A,0x23,0xA4,0xAB,0x5A,0xB9,0xA2,0x93,0x13,0x1D,0xA1,0x90,0xB6,0x32};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x53,0x15,0x4F,0xED,0xE9,0x4D,0x28,0x73,0x98,0x90,0x49,0x90,0x38,0x09,0xD7,0x98,0x0A,0x9F,0x04,0xFF,0x9E,0x02,0x7A,0x1D,0x6E,0xEB,0xF3,0xD6,0xFC,0x95,0x90,0xCF};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^254)*G
			{
				const static sl_uint8 _x[] = {0x2A,0x9E,0x8D,0xFE,0x3C,0xCE,0x6B,0xAB,0x3E,0x82,0xD8,0x2A,0x56,0x88,0x54,0x4C,0x0C,0x7B,0x55,0xDC,0x31,0x97,0x8B,0x4D,0xE2,0xCC,0xB3,0xB7,0xD4,0x66,0xD5,0x61};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0x01,0xDF,0xED,0xA5,0xC1,0x6E,0x65,0x1F,0xBA,0xC7,0xB5,0xAD,0x60,0x8B,0x96,0xCF,0x5E,0x01,0xEA,0xEC,0x17,0xA0,0x21,0x82,0xF9,0x6C,0xCF,0x52,0x52,0xE7,0x63,0x73};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			// (2^255)*G
			{
				const static sl_uint8 _x[] = {0xB2,0x37,0x90,0xA4,0x2B,0xE6,0x3E,0x1B,0x25,0x1A,0xD6,0xC9,0x4F,0xDE,0xF0,0x72,0x71,0xEC,0x0A,0xAD,0xA3,0x1D,0xB6,0xC3,0xE8,0xBD,0x32,0x04,0x3F,0x8B,0xE3,0x84};
				pt.x = BigInt::fromBytesBE(_x, sizeof(_x));
				const static sl_uint8 _y[] = {0xFC,0x6B,0x69,0x49,0x19,0xD5,0x5E,0xDB,0xE8,0xD5,0x0F,0x88,0xAA,0x81,0xF9,0x45,0x17,0xF0,0x04,0xF4,0x14,0x9E,0xCB,0x58,0xD1,0x0A,0x47,0x3D,0xEB,0x19,0x88,0x0E};
				pt.y = BigInt::fromBytesBE(_y, sizeof(_y));
				pow2g.add_NoLock(pt);
			}
			*/
		}
		
	};
	
	const EllipticCurve& EllipticCurve::secp256k1()
	{
		SLIB_SAFE_STATIC(EllipticCurve_secp256k1, ret)
		SLIB_STATIC_ZERO_INITIALIZED(EllipticCurve, zero)
		if (SLIB_SAFE_STATIC_CHECK_FREED(ret)) {
			return zero;
		}
		return ret;
	}
	
}
